Jak zdobyć klucz w obiekcie JavaScript według jego wartości?


387

Mam dość prosty obiekt JavaScript, którego używam jako tablicy asocjacyjnej. Czy istnieje prosta funkcja pozwalająca mi uzyskać klucz do wartości, czy też muszę iterować obiekt i znaleźć go ręcznie?


Nie ma takiej standardowej funkcji, aby to zrobić. Jeśli mapowanie jest naprawdę dwukierunkowe, wówczas zbudowanie „odwróconej” mapy i zindeksowanie tego jest trywialne. W przeciwnym razie prosty iterator właściwości (być może z

Jak to może działać, jeśli do obiektu odwołuje się więcej niż jeden klucz? var o = []; var map = {first: o, second: o}. Co by find_key(o)powrócił?
Gareth

3
nie ma znaczenia;) Chciałem użyć go tylko do tablicy z unikalnymi parami klucz-wartość.
arik


Stworzyłem wersję bez iteracji stackoverflow.com/a/36705765/696535 . Interesujące byłoby przetestowanie wszystkich proponowanych rozwiązań w jsfiddle
Paweł

Odpowiedzi:


91

Dzięki bibliotece Underscore.js :

var hash = {
  foo: 1,
  bar: 2
};

(_.invert(hash))[1]; // => 'foo'

381
@GeorgeJempty Nie każdy chce załadować bibliotekę 5kb do prostego wyszukiwania klucza;)
tckmn

4
Tylko FYI dla każdego, kto szuka rozwiązania, które da WSZYSTKIE klucze pasujące do wartości: to nie zadziała.
Brett,

2
Klawisze podkreślenia również będą działać. underscorejs.org/#keys _.keys ({one: 1, two: 2, three: 3}); => [„jeden”, „dwa”, „trzy”]
Thaddeus Albers

1
_.invert nie działa tam, gdzie wartości zawierają obiekty, gdy domyślna serializacja ciągu koliduje. Możesz użyć tej obrzydliwości:_.chain(hash).pairs().findWhere({1: 1}).value()[0]
DanHorner

3
To nie powinna być akceptowana odpowiedź, sugeruje rozwiązanie za pomocą biblioteki, które wymusza zmianę w obecnej strukturze kodu
Matteo,

591
function getKeyByValue(object, value) {
  return Object.keys(object).find(key => object[key] === value);
}

ES6, brak prototypowych mutacji lub bibliotek zewnętrznych.

Przykład,

function getKeyByValue(object, value) {
  return Object.keys(object).find(key => object[key] === value);
}


const map = {"first" : "1", "second" : "2"};
console.log(getKeyByValue(map,"2"));


8
Cóż, naprawdę czyste, jeśli nie obsługujesz IE11 :-) Jeśli tak, potrzebujesz wypełnienia
Chexpir

4
W zależności od implementacji zajmuje to prawdopodobnie przestrzeń O (n), ponieważ keys()materializuje zestaw kluczy.
David Ehrmann

2
Czysty, ale wolny.
Diriable

4
Jeśli wiele kluczy ma tę samą wartość, użyj filtru zamiast findfunction getKeyByValue(object, value) { return Object.keys(object).filter(key => object[key] === value); }
saketh

Lol. To nie jest powolne, to O (n), które jest właściwie najlepszym możliwym środowiskiem uruchomieniowym.
Ben Wainwright,

179

Brak dostępnej standardowej metody. Musisz iterować i możesz stworzyć prostego pomocnika:

Object.prototype.getKeyByValue = function( value ) {
    for( var prop in this ) {
        if( this.hasOwnProperty( prop ) ) {
             if( this[ prop ] === value )
                 return prop;
        }
    }
}

var test = {
   key1: 42,
   key2: 'foo'
};

test.getKeyByValue( 42 );  // returns 'key1'

Jedno słowo ostrzeżenia : Nawet jeśli powyższe działa, generalnie złym pomysłem jest rozszerzenie dowolnego hosta lub obiektu natywnego .prototype. Zrobiłem to tutaj, ponieważ bardzo dobrze pasuje do problemu. W każdym razie powinieneś prawdopodobnie użyć tej funkcji poza .prototypei przekazać do niej obiekt.


2
Właściwie jest w porządku, jeśli wiesz, że takie rzeczy pętla for-in idzie w dół łańcucha właściwości, co oznacza, że ​​„for (var key in obj)” da ci „getKeyByValue” jako „klucz” w pewnym momencie.

O rany, uwielbiam, jak to potajemnie powraca niezdefiniowane, jeśli wartość nie istnieje. Dobra robota. Ponadto, tylko punkt zainteresowania, wykona O (n), więc jeśli obiekt miałby mnóstwo właściwości (takich jak lista osób w dużym mieście i ich adresy), prawdopodobnie chciałbyś bardziej wydajnego wyszukiwania. Może sortuj wartości i wyszukiwanie binarne? Co?
corbin 10.11.13

Dziękuję bardzo, zanim zobaczyłem zły pomysł, zastanawiam się, dlaczego to przeszukałem i dodałem tutaj, aby poprawić tę odpowiedź i obszerną lekturę. stackoverflow.com/questions/3085240/…
simongcc

1
@ jAndy to NIE ===, to ==. Twój kod nie działa z ===. Zwraca niezdefiniowany.
Dexter,

Myślę, że przekształcenie go na ciąg byłoby lepiej błędów typu fix tylko dodać .toString()jak obj[ key ].toString()i wartości w razie potrzeby ...
CrandellWS

129

Jak już wspomniano, potrzebna jest iteracja. Na przykład w nowoczesnej przeglądarce możesz mieć:

var key = Object.keys(obj).filter(function(key) {return obj[key] === value})[0];

Gdzie valuezawiera wartość, której szukasz. Powiedziałem, że prawdopodobnie użyłbym pętli.

W przeciwnym razie możesz użyć odpowiedniego obiektu „hashmap” - istnieje kilka implementacji w JS - lub możesz to zrobić samodzielnie.

AKTUALIZACJA 2018

Minęło sześć lat, ale wciąż mam tu trochę głosów, więc mam wrażenie, że bardziej nowoczesne rozwiązanie - dla nowoczesnej przeglądarki / środowiska - powinno zostać wymienione w samej odpowiedzi, a nie tylko w komentarzach:

const key = Object.keys(obj).find(key => obj[key] === value);

Oczywiście może to być także funkcja:

const getKeyByValue = (obj, value) => 
        Object.keys(obj).find(key => obj[key] === value);

18
ES6:Object.keys(obj).or(o=>o[key] === value)
Benjamin Gruenbaum

Niestety funkcja strzałki nie jest jeszcze żadną „nowoczesną” przeglądarką, więc w tej chwili jest trochę bezużyteczna - używam jej w jetpack w Firefoksie Nightly, będzie w Firefox 22. W każdym razie nie wiem o żadnej ortablicy metoda i nie jest dla mnie jasne, jaki jest jej cel: docenię kilka dodatkowych szczegółów! :)
ZER0

1
Co do strzały, to nadchodzi i czekam na nią :) Na orpewno! Zostało to dopiero niedawno ocenione i zaakceptowane (nie sądzę, aby ktokolwiek jeszcze go wdrożył). To, co robi, to znalezienie pierwszego elementu tablicy pasującego do predykatu i zwrócenie go. Więc [1,2,3,4].or(x=>x>2)wróci 3i [1,2,3,4,5].or(x=>x<3)wróci 1. Coś w stylu FirstOrDefault C # :)
Benjamin Gruenbaum,

Tak, strzałka nadchodzi, ale trzeba będzie ją szeroko wykorzystać - chyba że tak jak ja, ktoś pracuje nad konkretnym silnikiem. Nie wiedziałem o nowej propozycji dla ES6, myślałem, że jest dość zamknięty: czy masz link do tej ormetody? Z tego, co wspomniałeś, wydaje się, że zwraca element pasujący do predykatu „lub” samej tablicy?
ZER0

1
@ sg552, jak wspomniano później, orzostał przemianowany. Wierzę, że teraz powinieneś użyć find .
ZER0

42

Sposób na lodash https://lodash.com/docs#findKey

var users = {
  'barney':  { 'age': 36, 'active': true },
  'fred':    { 'age': 40, 'active': false },
  'pebbles': { 'age': 1,  'active': true }
};

_.findKey(users, { 'age': 1, 'active': true });
// → 'pebbles'


Lodash jest zdecydowanie najlepszym rozwiązaniem tego problemu. Uważam, że nawet lepszy niż podkreślenie.
arik

4
FYI, „sposób podkreślenia”: _.findKey(users, { 'age': 1, 'active': true });... to to samo
craigmichaelmartin,

jeśli tablica jest wartością, której należy użyć: - niech obj = {a: [1, 2], b: [3, 4], c: [5, 6]} _.findKey (obj, function (val) { return _.isEqual (val, [5, 6]);});
ashishyadaveee11

8
jeśli twoje wartości są proste, takie jak ciągi lub liczby całkowite, to wbrew oczekiwaniom to nie zadziała. np. _.find_key({a: "A", b:"B"}, "B"})zwraca, undefinedtak jak podano tutaj , musisz to zrobić _.find_key({a: "A", b:"B"}, _.partial(_.isEqual,"B")})
ryan2johnson9

1
@ ryan2johnson9 To mój problem z Lodash. Trudno mi zrozumieć niektóre funkcje (najwyraźniej jestem jedyną). Ale dzięki i tak to działa. Znalazłem inne, krótsze rozwiązanie. Powoduje to przesypywanie się większych obiektów, więc bądź ostrożny z tym. _.invert(haystack)[needle]
Empi,

33
function extractKeyValue(obj, value) {
    return Object.keys(obj)[Object.values(obj).indexOf(value)];
}

Stworzony dla kompilatora zamykającego w celu wyodrębnienia nazwy klucza, która po kompilacji będzie nieznana

Bardziej seksowna wersja, ale wykorzystująca Object.entriesfunkcję przyszłości

function objectKeyByValue (obj, val) {
  return Object.entries(obj).find(i => i[1] === val);
}

7
Myślę, że jest to najlepszy dla 2017+, ponieważ używa zwykłego JavaScript.
brainbag

Nie działa, jeśli masz dwie lub więcej liczb o tej samej wartości
JuicY_Burrito

@SamuelChen to prawda, ale jeśli zadziałałoby, oznaczałoby to, że w rezultacie potrzebna jest tablica. Gdzie zamiast tego Object.entries(obj).find(i => i[1] === val);użyjfilterObject.entries(obj).filter(i => i[1] === val);
Paweł

24

ES6 + One Liners

let key = Object.keys(obj).find(k=>obj[k]===value);

Zwróć wszystkie klucze z wartością:

let keys = Object.keys(obj).filter(k=>obj[k]===value);

1
Powinna być zaakceptowana odpowiedź, ponieważ nie ma zależności.
Andrew Schultz

22

Korzystam z tej funkcji:

Object.prototype.getKey = function(value){
  for(var key in this){
    if(this[key] == value){
      return key;
    }
  }
  return null;
};

Stosowanie:

// ISO 639: 2-letter codes
var languageCodes = {
  DA: 'Danish',
  DE: 'German',
  DZ: 'Bhutani',
  EL: 'Greek',
  EN: 'English',
  EO: 'Esperanto',
  ES: 'Spanish'
};

var key = languageCodes.getKey('Greek');
console.log(key); // EL

10
+1 zgrabne rozwiązanie. Ale mam pytanie: czy nie powinieneś zawsze sprawdzać, obj.hasOwnProperty(key)czy w tym przypadku nie jest to konieczne?
V-Light

5
Mutowanie prototypu obiektu to zła praktyka: stackoverflow.com/questions/23807805/…
Jon Koops

18

Rozwiązanie niemożliwe do powtórzenia

Główna funkcja:

var keyByValue = function(value) {

    var kArray = Object.keys(greetings);        // Creating array of keys
    var vArray = Object.values(greetings);      // Creating array of values
    var vIndex = vArray.indexOf(value);         // Finding value index 

    return kArray[vIndex];                      // Returning key by value index
}

Obiekt z kluczami i wartościami:

var greetings = {
    english   : "hello",
    ukranian  : "привіт"
};

Test:

keyByValue("привіт");
// => "ukranian"

prostsze: Object.keys(greetings )[Object.values(greetings ).indexOf('привіт')]
Shutsman

16

Utrzymuj swój prototyp w czystości.

function val2key(val,array){
    for (var key in array) {
        if(array[key] == val){
            return key;
        }
    }
 return false;
}

Przykład:

var map = {"first" : 1, "second" : 2};
var key = val2key(2,map); /*returns "second"*/

15

Jeśli pracujesz z biblioteką Underscore lub Lodash , możesz użyć funkcji _.findKey :

var users = {
  'barney':  { 'age': 36, 'active': true },
  'fred':    { 'age': 40, 'active': false },
  'pebbles': { 'age': 1,  'active': true }
};

_.findKey(users, function(o) { return o.age < 40; });
// => 'barney' (iteration order is not guaranteed)

// The `_.matches` iteratee shorthand.
_.findKey(users, { 'age': 1, 'active': true });
// => 'pebbles'

// The `_.matchesProperty` iteratee shorthand.
_.findKey(users, ['active', false]);
// => 'fred'

// The `_.property` iteratee shorthand.
_.findKey(users, 'active');
// => 'barney'

13

Stworzyłem bibliotekę bimap ( https://github.com/alethes/bimap ), która implementuje potężny, elastyczny i wydajny interfejs map dwukierunkowych JavaScript. Nie ma żadnych zależności i można go używać zarówno po stronie serwera (w Node.js można go zainstalować npm install bimap), jak iw przeglądarce (poprzez link do lib / bimap.js ).

Podstawowe operacje są bardzo proste:

var bimap = new BiMap;
bimap.push("k", "v");
bimap.key("k") // => "v"
bimap.val("v") // => "k"

bimap.push("UK", ["London", "Manchester"]);
bimap.key("UK"); // => ["London", "Manchester"]
bimap.val("London"); // => "UK"
bimap.val("Manchester"); // => "UK"

Pobieranie mapowania klucz-wartość jest równie szybkie w obu kierunkach. Pod maską nie ma kosztownych przejść między obiektami / tablicami, więc średni czas dostępu pozostaje stały, niezależnie od wielkości danych.


Jedno z niewielu rozwiązań, które nie wymaga iteracji (w samym rozwiązaniu, bibliotece standardowej lub innej bibliotece).
Scott Rudiger,

6

nie widział:

const obj = {
  id: 1,
  name: 'Den'
};

function getKeyByValue(obj, value) {
  return Object.entries(obj).find(([, name]) => value === name);
}

const [ key ] = getKeyByValue(obj, 'Den');
console.log(key)
  


5

Ponieważ wartości są unikalne, powinno być możliwe dodanie wartości jako dodatkowego zestawu kluczy. Można to zrobić za pomocą następującego skrótu.

var foo = {};
foo[foo.apple = "an apple"] = "apple";
foo[foo.pear = "a pear"] = "pear";

Umożliwiłoby to pobieranie za pomocą klucza lub wartości:

var key = "apple";
var value = "an apple";

console.log(foo[value]); // "apple"
console.log(foo[key]); // "an apple"

Zakłada się, że nie ma wspólnych elementów między kluczami a wartościami.


Przeglądając wszystkie rozwiązania, poszedłem z tym jednym. Bardzo intuicyjny.
nehem

1
Jedno z niewielu rozwiązań, które nie wymaga iteracji (w samym rozwiązaniu, bibliotece standardowej lub innej bibliotece).
Scott Rudiger

OP stwierdził, że wszystkie pary klucz / wartość są wyjątkowe, dlatego ta odpowiedź na temat niskiej technologii jest po prostu fantastyczna! Dobra robota;)
komendant niestandardowy

4

Biorąc pod uwagę input={"a":"x", "b":"y", "c":"x"}...

  • Aby użyć pierwszej wartości (np. output={"x":"a","y":"b"}):

input = {
  "a": "x",
  "b": "y",
  "c": "x"
}
output = Object.keys(input).reduceRight(function(accum, key, i) {
  accum[input[key]] = key;
  return accum;
}, {})
console.log(output)

  • Aby użyć ostatniej wartości (np. output={"x":"c","y":"b"}):

input = {
  "a": "x",
  "b": "y",
  "c": "x"
}
output = Object.keys(input).reduce(function(accum, key, i) {
  accum[input[key]] = key;
  return accum;
}, {})
console.log(output)

  • Aby uzyskać tablicę kluczy dla każdej wartości (np. output={"x":["c","a"],"y":["b"]}):

input = {
  "a": "x",
  "b": "y",
  "c": "x"
}
output = Object.keys(input).reduceRight(function(accum, key, i) {
  accum[input[key]] = (accum[input[key]] || []).concat(key);
  return accum;
}, {})
console.log(output)


1
to zdecydowanie najlepsza odpowiedź, ale drapałem się po głowie, aby ją przekształcić, aby zwrócić tylko klucz dla danego obiektu, tj. być funkcjonalnie równoważnym z indeksem index dla tablicy.
Souhaieb Besbes

O ile pamięć nie jest ograniczeniem i nie jesteś w stanie wydać dużo mocy obliczeniowej, aby przeglądać obiekt wiele razy, po prostu zapisz „wynik”, jak wskazano powyżej, do zmiennej i sprawdź wynik tam ... jak output['x']. Czy o to pytałeś?
Fabio Beltramini

2

http://jsfiddle.net/rTazZ/2/

var a = new Array(); 
    a.push({"1": "apple", "2": "banana"}); 
    a.push({"3": "coconut", "4": "mango"});

    GetIndexByValue(a, "coconut");

    function GetIndexByValue(arrayName, value) {  
    var keyName = "";
    var index = -1;
    for (var i = 0; i < arrayName.length; i++) { 
       var obj = arrayName[i]; 
            for (var key in obj) {          
                if (obj[key] == value) { 
                    keyName = key; 
                    index = i;
                } 
            } 
        }
        //console.log(index); 
        return index;
    } 

@ Fr0zenFyr: Poniższy link może lepiej odpowiedzieć na pytanie - stackoverflow.com/questions/8423493/…
Atur

2

Lub jeszcze łatwiej - utwórz nowy obiekt z kluczami i wartościami w żądanej kolejności, a następnie spójrz w górę na ten obiekt. Wystąpiły konflikty przy użyciu powyższych prototypowych kodów. Nie musisz używać funkcji String wokół klawisza, która jest opcjonalna.

 newLookUpObj = {};
 $.each(oldLookUpObj,function(key,value){
        newLookUpObj[value] = String(key);
    });


2

Jakby to pytanie nie zostało rozbite na miazgę ...

Oto jedna z ciekawości, jaką przyniesie ci ...

Jeśli masz pewność, że Twój obiekt będzie miał tylko wartości łańcuchowe, możesz naprawdę się wyczarować, aby wyczarować tę implementację:

var o = { a: '_A', b: '_B', c: '_C' }
  , json = JSON.stringify(o)
  , split = json.split('')
  , nosj = split.reverse()
  , o2 = nosj.join('');

var reversed = o2.replace(/[{}]+/g, function ($1) { return ({ '{':'}', '}':'{' })[$1]; })
  , object = JSON.parse(reversed)
  , value = '_B'
  , eulav = value.split('').reverse().join('');

console.log('>>', object[eulav]);

Może jest tu coś użytecznego do zbudowania ...

Mam nadzieję, że to cię bawi.


2

Oto rozwiązanie Lodash, które działa dla płaskiego obiektu kluczowego =>, a nie dla obiektu zagnieżdżonego. Sugerowana do zaakceptowania propozycja odpowiedzi_.findKey działa z obiektami z obiektami zagnieżdżonymi, ale nie działa w tych powszechnych okolicznościach.

Takie podejście odwraca obiekt, zamieniając klucze na wartości, a następnie znajduje klucz, wyszukując wartość nowego (odwróconego) obiektu. Jeśli klucz nie zostanie znaleziony, wówczas falsejest zwracany, co wolę ponad undefined, ale możesz łatwo zamienić go w trzecim parametrze _.getmetody w getKey().

// Get an object's key by value
var getKey = function( obj, value ) {
	var inverse = _.invert( obj );
	return _.get( inverse, value, false );
};

// US states used as an example
var states = {
	"AL": "Alabama",
	"AK": "Alaska",
	"AS": "American Samoa",
	"AZ": "Arizona",
	"AR": "Arkansas",
	"CA": "California",
	"CO": "Colorado",
	"CT": "Connecticut",
	"DE": "Delaware",
	"DC": "District Of Columbia",
	"FM": "Federated States Of Micronesia",
	"FL": "Florida",
	"GA": "Georgia",
	"GU": "Guam",
	"HI": "Hawaii",
	"ID": "Idaho",
	"IL": "Illinois",
	"IN": "Indiana",
	"IA": "Iowa",
	"KS": "Kansas",
	"KY": "Kentucky",
	"LA": "Louisiana",
	"ME": "Maine",
	"MH": "Marshall Islands",
	"MD": "Maryland",
	"MA": "Massachusetts",
	"MI": "Michigan",
	"MN": "Minnesota",
	"MS": "Mississippi",
	"MO": "Missouri",
	"MT": "Montana",
	"NE": "Nebraska",
	"NV": "Nevada",
	"NH": "New Hampshire",
	"NJ": "New Jersey",
	"NM": "New Mexico",
	"NY": "New York",
	"NC": "North Carolina",
	"ND": "North Dakota",
	"MP": "Northern Mariana Islands",
	"OH": "Ohio",
	"OK": "Oklahoma",
	"OR": "Oregon",
	"PW": "Palau",
	"PA": "Pennsylvania",
	"PR": "Puerto Rico",
	"RI": "Rhode Island",
	"SC": "South Carolina",
	"SD": "South Dakota",
	"TN": "Tennessee",
	"TX": "Texas",
	"UT": "Utah",
	"VT": "Vermont",
	"VI": "Virgin Islands",
	"VA": "Virginia",
	"WA": "Washington",
	"WV": "West Virginia",
	"WI": "Wisconsin",
	"WY": "Wyoming"
};

console.log( 'The key for "Massachusetts" is "' + getKey( states, 'Massachusetts' ) + '"' );
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js"></script>


2

Oto moje pierwsze rozwiązanie:

Na przykład przypuszczam, że mamy obiekt, który zawiera trzy pary wartości:

function findKey(object, value) {

    for (let key in object)
        if (object[key] === value) return key;

    return "key is not found";
}

const object = { id_1: "apple", id_2: "pear", id_3: "peach" };

console.log(findKey(object, "pear"));
//expected output: id_2

Możemy po prostu napisać findKey (tablica, wartość), który przyjmuje dwa parametry, które są obiektem i wartością szukanego klucza. Jako taka, ta metoda jest wielokrotnego użytku i nie trzeba ręcznie ręcznie iterować obiektu za każdym razem, przekazując tylko dwa parametry dla tej funkcji.


2

Metody ES6 :

Object.fromEntries(Object.entries(a).map(b => b.reverse()))['value_you_look_for']

0

Zazwyczaj zalecam lodash zamiast podkreślenia.

Jeśli go masz, użyj go.

Jeśli nie, powinieneś rozważyć użycie pakietu npm lodash.invert, który jest dość mały.

Oto jak możesz to przetestować za pomocą gulp:

1) Utwórz plik o nazwie gulpfile.js o następującej zawartości:

// Filename: gulpfile.js
var gulp = require('gulp');
var invert = require('lodash.invert');   
gulp.task('test-invert', function () {
  var hash = {
    foo: 1,
    bar: 2
  };
  var val = 1;
  var key = (invert(hash))[val];  // << Here's where we call invert!
  console.log('key for val(' + val + '):', key);
});

2) Zainstaluj pakiet lodash.invert i wypij

$ npm i --save lodash.invert && npm install gulp

3) Sprawdź, czy to działa:

$ gulp test-invert
[17:17:23] Using gulpfile ~/dev/npm/lodash-invert/gulpfile.js
[17:17:23] Starting 'test-invert'...
key for val(1): foo
[17:17:23] Finished 'test-invert' after 511 μs

Bibliografia

https://www.npmjs.com/package/lodash.invert

https://lodash.com/

Różnice między lodash a podkreśleniem

https://github.com/gulpjs/gulp


Dlaczego zaangażowany jest tutaj Gulp? Po prostu uruchom skrypt…
Ry-

0

Podkreśl rozwiązanie js

let samplLst = [{id:1,title:Lorem},{id:2,title:Ipsum}]
let sampleKey = _.findLastIndex(samplLst,{_id:2});
//result would be 1
console.log(samplLst[sampleKey])
//output - {id:2,title:Ipsum}

0

to działało dla mnie, aby uzyskać klucz / wartość obiektu.

let obj = {
        'key1': 'value1',
        'key2': 'value2',
        'key3': 'value3',
        'key4': 'value4'
    }
    Object.keys(obj).map(function(k){ 
    console.log("key with value: "+k +" = "+obj[k])    
    
    })
    


-1

Naprawdę proste.

const CryptoEnum = Object.freeze({
                    "Bitcoin": 0, "Ethereum": 1, 
                    "Filecoin": 2, "Monero": 3, 
                    "EOS": 4, "Cardano": 5, 
                    "NEO": 6, "Dash": 7, 
                    "Zcash": 8, "Decred": 9 
                  });

Object.entries(CryptoEnum)[0][0]
// output => "Bitcoin"

6
Nie ma gwarancji, że kolejność obiektów będzie taka sama ...
Downgoat,

-2

Nie komplikuj!

Nie musisz filtrować obiektu za pomocą wyrafinowanych metod lub bibliotek, JavaScript ma wbudowaną funkcję o nazwie Object.values .

Przykład:

let myObj = {jhon: {age: 20, job: 'Developer'}, marie: {age: 20, job: 
'Developer'}};

function giveMeTheObjectData(object, property) {
   return Object.values(object[property]);
}

giveMeTheObjectData(myObj, 'marie'); // => returns marie: {}

Spowoduje to zwrócenie danych właściwości obiektu.

Bibliografia

https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/values

Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.