Wie erhalte ich einen Schlüssel in einem JavaScript-Objekt anhand seines Werts?

Ich habe ein recht einfaches JavaScript-Objekt, das ich als assoziatives Array verwende. Gibt es eine einfache Funktion, mit der ich den Schlüssel für einen Wert abrufen kann, oder muss ich das Objekt iterieren und manuell herausfinden?

Mit der Bibliothek Underscore.js :

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

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

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

ES6, keine Prototypmutationen oder externe Bibliotheken.

Beispiel,

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


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

Keine Standardmethode verfügbar. Sie müssen iterieren und können einen einfachen Helfer erstellen:

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'

Ein Wort der Vorsicht : Auch wenn das oben genannte funktioniert, ist es im Allgemeinen eine schlechte Idee, Hosts oder native Objekte zu erweitern .prototype. Ich habe es hier gemacht, weil es sehr gut zum Thema passt. Auf jeden Fall sollten Sie diese Funktion wahrscheinlich außerhalb von verwenden .prototypeund stattdessen das Objekt übergeben.

Wie gesagt, ist eine Iteration erforderlich. In einem modernen Browser könnten Sie beispielsweise Folgendes haben:

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

Wo value enthält der Wert, den Sie suchen. Sagte, ich würde wahrscheinlich eine Schleife verwenden.

Andernfalls könnten Sie ein geeignetes "Hashmap" -Objekt verwenden - es gibt mehrere Implementierungen in JS - oder es selbst implementieren.

UPDATE 2018

Sechs Jahre sind vergangen, aber ich bekomme hier immer noch einige Stimmen, daher denke ich, dass eine modernere Lösung - für moderne Browser / Umgebungen - in der Antwort selbst und nicht nur in den Kommentaren erwähnt werden sollte:

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

Natürlich kann es auch eine Funktion sein:

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

Der lodash Weg 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'

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

Für den Closure-Compiler gemacht, um Schlüsselnamen zu extrahieren, die nach der Kompilierung unbekannt sind

Sexy Version, aber mit zukünftiger Object.entriesFunktion

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

ES6 + One Liner

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

Geben Sie alle Schlüssel mit dem Wert zurück:

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

Ich benutze diese Funktion:

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

Verwendungszweck:

// 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

Nicht iterierbare Lösung

Hauptfunktion:

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
}

Objekt mit Schlüsseln und Werten:

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

Prüfung:

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

Halten Sie Ihren Prototyp sauber.

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

Beispiel:

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

Wenn Sie mit einer Underscore- oder Lodash- Bibliothek arbeiten, können Sie die Funktion _.findKey verwenden:

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'

Ich habe die Bimap- Bibliothek ( https://github.com/alethes/bimap ) erstellt, die eine leistungsstarke, flexible und effiziente bidirektionale JavaScript-Kartenschnittstelle implementiert. Es hat keine Abhängigkeiten und kann sowohl auf der Serverseite (in Node.js können Sie es installieren npm install bimap) als auch im Browser (durch Verknüpfen mit lib / bimap.js ) verwendet werden.

Grundlegende Operationen sind wirklich einfach:

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"

Das Abrufen der Schlüsselwertzuordnung erfolgt in beide Richtungen gleich schnell. Unter der Haube befinden sich keine kostspieligen Objekt- / Array-Durchquerungen, sodass die durchschnittliche Zugriffszeit unabhängig von der Größe der Daten konstant bleibt.

habe folgendes nicht gesehen:

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)

Da die Werte eindeutig sind, sollte es möglich sein, die Werte als zusätzlichen Schlüsselsatz hinzuzufügen. Dies könnte mit der folgenden Verknüpfung erfolgen.

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

Dies würde das Abrufen entweder über den Schlüssel oder den Wert ermöglichen:

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

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

Dies setzt voraus, dass es keine gemeinsamen Elemente zwischen den Schlüsseln und Werten gibt.

Gegeben input={"a":"x", "b":"y", "c":"x"}...

• So verwenden Sie den ersten Wert (z. B. 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)

• So verwenden Sie den letzten Wert (z. B. 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)

• So erhalten Sie ein Array von Schlüsseln für jeden Wert (z. B. 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)

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;
    } 

Oder noch einfacher: Erstellen Sie ein neues Objekt mit den Schlüsseln und Werten in der gewünschten Reihenfolge und suchen Sie dann nach diesem Objekt. Wir hatten Konflikte mit den oben genannten Prototypcodes. Sie müssen die String-Funktion nicht um den Schlüssel herum verwenden, das ist optional.

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

Dies ist eine kleine Erweiterung der Underscorejs-Methode und verwendet stattdessen Lodash :

var getKeyByValue = function(searchValue) {
  return _.findKey(hash, function(hashValue) {
    return searchValue === hashValue;
  });
}

FindKey wird die erste Taste suchen und zurückgeben , die den Wert übereinstimmt.
Wenn Sie stattdessen die letzte Übereinstimmung wünschen, verwenden Sie stattdessen FindLastKey .

Als ob diese Frage nicht zu Brei geschlagen worden wäre ...

Hier ist eine, nur für die Neugier, die sie Ihnen bringt ...

Wenn Sie sicher sind, dass Ihr Objekt nur Zeichenfolgenwerte enthält, können Sie sich wirklich erschöpfen, um diese Implementierung zu erstellen:

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]);

Vielleicht gibt es hier etwas Nützliches zu bauen ...

Hoffe das amüsiert dich.

Hier ist eine Lodash-Lösung dafür, die für ein Objekt mit flachem Schlüssel => Wert und nicht für ein verschachteltes Objekt funktioniert. Der Vorschlag der akzeptierten Antwort zur Verwendung_.findKey funktioniert für Objekte mit verschachtelten Objekten, funktioniert jedoch unter diesen allgemeinen Umständen nicht.

Dieser Ansatz invertiert das Objekt, tauscht Schlüssel gegen Werte aus und findet den Schlüssel dann, indem er den Wert des neuen (invertierten) Objekts nachschlägt. Wenn der Schlüssel nicht gefunden wird, falsewird er zurückgegeben, was ich vorziehe undefined, aber Sie können dies leicht im dritten Parameter der _.getMethode in austauschen 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>

Hier ist zuerst meine Lösung:

Zum Beispiel nehme ich an, dass wir ein Objekt haben, das drei Wertepaare enthält:

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

Wir können einfach einen findKey (Array, Wert) schreiben, der zwei Parameter akzeptiert, die ein Objekt und den Wert des gesuchten Schlüssels sind. Daher ist diese Methode wiederverwendbar und Sie müssen das Objekt nicht jedes Mal manuell iterieren, indem Sie nur zwei Parameter für diese Funktion übergeben.

ES6- Methoden:

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

Ich empfehle eher lodash als Unterstrich.

Wenn Sie es haben, verwenden Sie es.

Wenn Sie dies nicht tun, sollten Sie in Betracht ziehen, das Paket lodash.invert npm zu verwenden, das ziemlich klein ist.

So können Sie es mit gulp testen:

1) Erstellen Sie eine Datei namens gulpfile.js mit folgendem Inhalt:

// 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) Installieren Sie das lodash.invert-Paket und schlucken Sie

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

3) Testen Sie, ob es funktioniert:

$ 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

Verweise

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

https://lodash.com/

Unterschiede zwischen lodash und Unterstrich

https://github.com/gulpjs/gulp

Unterstreichen Sie js Lösung

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}

Dies funktionierte für mich, um den Schlüssel / Wert des Objekts zu erhalten.

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

Wirklich unkompliziert.

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"

Halte es einfach!

Sie müssen das Objekt nicht durch ausgefeilte Methoden oder Bibliotheken filtern. Javascript verfügt über eine integrierte Funktion namens Object.values . .

Beispiel:

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: {}

Dadurch werden die Objekteigenschaftsdaten zurückgegeben.

Verweise

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