Come ottenere una chiave in un oggetto JavaScript in base al suo valore?

Ho un oggetto JavaScript abbastanza semplice, che uso come array associativo. Esiste una semplice funzione che mi consente di ottenere la chiave per un valore o devo iterare l'oggetto e trovarlo manualmente?

Con la libreria 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, nessuna mutazione prototipo o librerie esterne.

Esempio,

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


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

Nessun metodo standard disponibile. Devi iterare e puoi creare un semplice aiuto:

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'

Un avvertimento : anche se quanto sopra funziona, è generalmente una cattiva idea estendere qualsiasi host o oggetto nativo .prototype. L'ho fatto qui perché si adatta molto bene al problema. Ad ogni modo, dovresti probabilmente usare questa funzione al di fuori .prototypee passare invece l'oggetto al suo interno.

Come detto, è necessaria l'iterazione. Ad esempio, nel browser moderno potresti avere:

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

Dove valuecontiene il valore che stai cercando. Detto questo, probabilmente userei un loop.

Altrimenti potresti usare un oggetto "hashmap" appropriato - ci sono diverse implementazioni in JS in giro - o implementare da solo.

AGGIORNAMENTO 2018

Sono trascorsi sei anni, ma ho ancora qualche voto qui, quindi mi sento come una soluzione più moderna - per browser / ambiente moderni - dovrebbe essere menzionata nella risposta stessa e non solo nei commenti:

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

Naturalmente può anche essere una funzione:

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

The lodash way 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)];
}

Creato per il compilatore di chiusura per estrarre il nome della chiave che sarà sconosciuto dopo la compilazione

Versione più sexy ma utilizzando la Object.entriesfunzione futura

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

ES6 + One Liners

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

Restituisce tutte le chiavi con il valore:

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

Uso questa funzione:

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

Uso:

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

Soluzione non iterabile

Funzione principale:

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
}

Oggetto con chiavi e valori:

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

Test:

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

Tieni il tuo pulito il prototipo .

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

Esempio:

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

Se stai lavorando con la libreria Underscore o Lodash , puoi utilizzare la funzione _.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'

Ho creato la libreria bimap ( https://github.com/alethes/bimap ) che implementa un'interfaccia di mappa bidirezionale JavaScript potente, flessibile ed efficiente. Non ha dipendenze ed è utilizzabile sia sul lato server (in Node.js, è possibile installarlo con npm install bimap) sia nel browser (collegandosi a lib / bimap.js ).

Le operazioni di base sono davvero semplici:

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"

Il recupero della mappatura dei valori-chiave è altrettanto veloce in entrambe le direzioni. Non ci sono costosi attraversamenti di oggetti / array sotto il cofano, quindi il tempo medio di accesso rimane costante indipendentemente dalla dimensione dei dati.

non ho visto quanto segue:

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)

Poiché i valori sono univoci, dovrebbe essere possibile aggiungere i valori come set aggiuntivo di chiavi. Questo potrebbe essere fatto con il seguente collegamento.

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

Ciò consentirebbe il recupero tramite la chiave o il valore:

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

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

Questo presuppone che non ci siano elementi comuni tra le chiavi e i valori.

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

• Per utilizzare il primo valore (ad es. 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)

• Per utilizzare l'ultimo valore (ad es. 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)

• Per ottenere una matrice di chiavi per ciascun valore (ad es. 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;
    } 

Oppure, ancora più semplice: crea un nuovo oggetto con le chiavi e i valori nell'ordine desiderato, quindi cerca lo stesso oggetto. Abbiamo avuto conflitti utilizzando i codici prototipo sopra. Non è necessario utilizzare la funzione String attorno alla chiave, che è facoltativa.

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

Questa è una piccola estensione del metodo Underscorejs e utilizza invece Lodash :

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

FindKey cercherà e restituirà la prima chiave che corrisponde al valore.
Se invece vuoi l'ultima partita, usainvece FindLastKey .

Come se questa domanda non fosse stata fatta a pezzi ...

Eccone uno solo per la curiosità che ti porta ...

Se sei sicuro che il tuo oggetto avrà solo valori stringa, potresti davvero esaurirti per evocare questa implementazione:

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

Forse c'è qualcosa di utile da costruire di qui ...

Spero che questo ti diverta.

Ecco una soluzione Lodash a questo che funziona con chiave piatta => oggetto valore, piuttosto che un oggetto nidificato. Il suggerimento della risposta accettata da usare_.findKey funziona per oggetti con oggetti nidificati, ma non funziona in questa circostanza comune.

Questo approccio inverte l'oggetto, scambiando le chiavi per i valori, quindi trova la chiave cercando il valore sul nuovo oggetto (invertito). Se la chiave non viene trovata, falseviene restituita, cosa che preferisco undefined, ma è possibile sostituirla facilmente nel terzo parametro del _.getmetodo in 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>

Ecco prima la mia soluzione:

Ad esempio, suppongo che abbiamo un oggetto che contiene tre coppie di valori:

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

Possiamo semplicemente scrivere un findKey (array, valore) che accetta due parametri che sono un oggetto e il valore della chiave che stai cercando. Pertanto, questo metodo è riutilizzabile e non è necessario iterare manualmente l'oggetto ogni volta passando solo due parametri per questa funzione.

Metodi ES6 :

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

In genere consiglio lodash piuttosto che un trattino basso.

Se ce l'hai, usalo.

In caso contrario, dovresti prendere in considerazione l'uso del pacchetto nash lodash.invert, che è piuttosto piccolo.

Ecco come puoi provarlo usando gulp:

1) Crea un file chiamato gulpfile.js con i seguenti contenuti:

// 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) Installa il pacchetto lodash.invert e gulp

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

3) Verifica che funzioni:

$ 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

Riferimenti

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

https://lodash.com/

Differenze tra lodash e underscore

https://github.com/gulpjs/gulp

Underscore js solution

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}

questo ha funzionato per me per ottenere chiave / valore dell'oggetto.

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

Davvero semplice.

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"

Mantienilo semplice!

Non è necessario filtrare l'oggetto tramite metodi o librerie sofisticati, Javascript ha una funzione integrata chiamata Object.values .

Esempio:

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

Ciò restituirà i dati delle proprietà dell'oggetto.

Riferimenti

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