Comment obtenir une clé dans un objet JavaScript par sa valeur?

J'ai un objet JavaScript assez simple, que j'utilise comme tableau associatif. Existe-t-il une fonction simple me permettant d'obtenir la clé d'une valeur, ou dois-je itérer l'objet et le trouver manuellement?

Avec la bibliothèque 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, pas de mutations prototypes ni de bibliothèques externes.

Exemple,

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


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

Pas de méthode standard disponible. Vous devez itérer et vous pouvez créer un assistant simple:

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 mot d'avertissement : même si ce qui précède fonctionne, c'est généralement une mauvaise idée d'étendre n'importe quel hôte ou objet natif .prototype. Je l'ai fait ici parce que cela correspond très bien au problème. Quoi qu'il en soit, vous devriez probablement utiliser cette fonction en dehors de .prototypeet y passer l'objet à la place.

Comme dit, l'itération est nécessaire. Par exemple, dans un navigateur moderne, vous pourriez avoir:

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

Où value contient la valeur que vous recherchez. Dit cela, j'utiliserais probablement une boucle.

Sinon, vous pouvez utiliser un objet "hashmap" approprié - il existe plusieurs implémentations dans JS - ou l'implémenter par vous-même.

MISE À JOUR 2018

Six ans se sont écoulés, mais j'ai encore un certain vote ici, donc je pense qu'une solution plus moderne - pour un navigateur / environnement moderne - devrait être mentionnée dans la réponse elle-même et pas seulement dans les commentaires:

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

Bien sûr, cela peut aussi être une fonction:

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

La manière 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'

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

Conçu pour le compilateur de fermeture pour extraire le nom de la clé qui sera inconnu après la compilation

Version plus sexy mais utilisant la Object.entriesfonction future

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

Renvoie toutes les clés avec la valeur:

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

J'utilise cette fonction:

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

Usage:

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

Solution non itérable

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

Objet avec clés et valeurs:

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

Tester:

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

Gardez votre prototype propre.

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

Exemple:

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

Si vous travaillez avec la bibliothèque Underscore ou Lodash , vous pouvez utiliser la fonction _.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'

J'ai créé la bibliothèque bimap ( https://github.com/alethes/bimap ) qui implémente une interface de carte bidirectionnelle JavaScript puissante, flexible et efficace. Il n'a pas de dépendances et est utilisable à la fois côté serveur (dans Node.js, vous pouvez l'installer avec npm install bimap) et dans le navigateur (en créant un lien vers lib / bimap.js ).

Les opérations de base sont vraiment simples:

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"

La récupération du mappage de valeur-clé est également rapide dans les deux sens. Il n'y a pas de traversées d'objets / tableaux coûteuses sous le capot, donc le temps d'accès moyen reste constant quelle que soit la taille des données.

n'a pas vu ce qui suit:

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)

Étant donné que les valeurs sont uniques, il devrait être possible d'ajouter les valeurs en tant que jeu de clés supplémentaires. Cela pourrait être fait avec le raccourci suivant.

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

Cela permettrait la récupération soit via la clé ou la valeur:

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

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

Cela suppose qu'il n'y a pas d'éléments communs entre les clés et les valeurs.

Étant donné input={"a":"x", "b":"y", "c":"x"}...

• Pour utiliser la première valeur (par exemple 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)

• Pour utiliser la dernière valeur (par exemple 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)

• Pour obtenir un tableau de clés pour chaque valeur (par exemple 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;
    } 

Ou, encore plus simple - créez un nouvel objet avec les clés et les valeurs dans l'ordre souhaité, puis recherchez cet objet. Nous avons eu des conflits en utilisant les codes prototypes ci-dessus. Vous n'avez pas besoin d'utiliser la fonction String autour de la clé, qui est facultative.

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

Il s'agit d'une petite extension de la méthode Underscorejs, et utilise Lodash à la place:

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

FindKey va chercher et retourner la première clé qui correspondla valeur.
Si vous souhaitez plutôt la dernière correspondance, utilisezplutôt FindLastKey .

Comme si cette question n'avait pas été battue en bouillie ...

En voici une juste pour la curiosité qu'elle vous apporte ...

Si vous êtes sûr que votre objet n'aura que des valeurs de chaîne, vous pourriez vraiment vous épuiser pour évoquer cette implémentation:

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

Peut-être qu'il y a quelque chose d'utile à construire à partir d'ici ...

J'espère que cela vous amusera.

Voici une solution Lodash à cela qui fonctionne pour un objet clé => valeur, plutôt qu'un objet imbriqué. La suggestion de réponse acceptée à utiliser_.findKey œuvres pour les objets avec des objets imbriqués, mais cela ne fonctionne pas dans cette circonstance courante.

Cette approche inverse l'objet, en échangeant des clés contre des valeurs, puis trouve la clé en recherchant la valeur sur le nouvel objet (inversé). Si la clé n'est pas trouvée, elle falseest renvoyée, ce que je préfère undefined, mais vous pouvez facilement l'échanger dans le troisième paramètre de la _.getméthode dans 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>

Voici ma solution d'abord:

Par exemple, je suppose que nous avons un objet qui contient trois paires de valeurs:

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

Nous pouvons simplement écrire une findKey (tableau, valeur) qui prend deux paramètres qui sont un objet et la valeur de la clé que vous recherchez. En tant que telle, cette méthode est réutilisable et vous n'avez pas besoin d'itérer manuellement l'objet à chaque fois en ne passant que deux paramètres pour cette fonction.

Méthodes ES6 :

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

Je recommande généralement le lodash plutôt que le soulignement.

Si vous l'avez, utilisez-le.

Si vous ne le faites pas, vous devriez envisager d'utiliser le paquet nash lodash.invert, qui est assez petit.

Voici comment vous pouvez le tester à l'aide de gulp:

1) Créez un fichier appelé gulpfile.js avec le contenu suivant:

// 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) Installez le paquet lodash.invert et gulp

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

3) Vérifiez que cela fonctionne:

$ 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

Références

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

https://lodash.com/

Différences entre lodash et underscore

https://github.com/gulpjs/gulp

Souligner la solution 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}

cela a fonctionné pour moi pour obtenir la clé / valeur de l'objet.

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

Vraiment simple.

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"

Rester simple!

Vous n'avez pas besoin de filtrer l'objet à l'aide de méthodes sophistiquées ou de bibliothèques, Javascript a une fonction intégrée appelée Object.values .

Exemple:

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

Cela renverra les données de propriété de l'objet.

Références

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