¿Cómo obtener una clave en un objeto JavaScript por su valor?

Tengo un objeto JavaScript bastante simple, que uso como una matriz asociativa. ¿Existe una función simple que me permita obtener la clave para un valor, o tengo que iterar el objeto y encontrarlo manualmente?

Con la biblioteca 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, sin mutaciones prototipo o bibliotecas externas.

Ejemplo,

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


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

No hay un método estándar disponible. Necesita iterar y puede crear un ayudante 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'

Una advertencia : incluso si lo anterior funciona, generalmente es una mala idea extender cualquier host u objeto nativo .prototype. Lo hice aquí porque encaja muy bien con el problema. De todos modos, probablemente debería usar esta función fuera del .prototypey pasar el objeto en su lugar.

Como se dijo, se necesita iteración. Por ejemplo, en el navegador moderno podría tener:

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

Donde valuecontiene el valor que estás buscando. Dicho eso, probablemente usaría un bucle.

De lo contrario, podría usar un objeto "hashmap" adecuado (hay varias implementaciones en JS) o implementarlo usted mismo.

ACTUALIZACIÓN 2018

Pasaron seis años, pero todavía obtengo algo de voto aquí, así que siento que una solución más moderna, para el navegador / entorno moderno, debería mencionarse en la respuesta en sí y no solo en los comentarios:

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

Por supuesto, también puede ser una función:

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

La forma 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)];
}

Hecho para el compilador de cierre para extraer el nombre clave que será desconocido después de la compilación

Versión más sexy pero con Object.entriesfunción 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);

Devuelve todas las claves con el valor:

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

Yo uso esta función:

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

Solución no iterable

Función principal:

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
}

Objeto con claves y valores:

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

Prueba:

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

Mantenga su prototipo limpio.

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

Ejemplo:

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

Si está trabajando con la biblioteca Underscore o Lodash , puede usar la función _.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'

He creado el BIMAP biblioteca ( https://github.com/alethes/bimap ) que implementa un potente, flexible y eficiente interfaz del mapa bidireccional JavaScript. No tiene dependencias y se puede usar tanto en el lado del servidor (en Node.js, puede instalarlo con npm install bimap) como en el navegador (al vincular a lib / bimap.js ).

Las operaciones básicas son realmente 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 recuperación del mapeo clave-valor es igualmente rápida en ambas direcciones. No hay recorridos costosos de objetos / conjuntos debajo del capó, por lo que el tiempo de acceso promedio permanece constante independientemente del tamaño de los datos.

no vi lo siguiente:

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)

Como los valores son únicos, debería ser posible agregar los valores como un conjunto adicional de claves. Esto podría hacerse con el siguiente acceso directo.

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

Esto permitiría la recuperación a través de la clave o el valor:

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

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

Esto supone que no hay elementos comunes entre las claves y los valores.

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

• Para usar el primer valor (por ejemplo 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)

• Para usar el último valor (por ejemplo 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)

• Para obtener una matriz de claves para cada valor (por ejemplo 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;
    } 

O, aún más fácil: cree un nuevo objeto con las claves y los valores en el orden que desee y luego busque ese objeto. Hemos tenido conflictos al usar los códigos prototipo anteriores. No tiene que usar la función String alrededor de la tecla, eso es opcional.

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

Esta es una pequeña extensión del método Underscorejs, y utiliza Lodash en su lugar:

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

FindKey buscará y devolverá la primera clave que coincida con el valor.
Si desea la última coincidencia, use FindLastKey en su lugar.

Como si esta pregunta no hubiera sido superada ...

Aquí hay uno para cualquier curiosidad que te traiga ...

Si está seguro de que su objeto solo tendrá valores de cadena, realmente podría agotarse para evocar esta implementación:

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

Tal vez hay algo útil para construir desde aquí ...

Espero que esto te divierta.

Aquí hay una solución de Lodash para esto que funciona para la clave plana => objeto de valor, en lugar de un objeto anidado. La sugerencia de la respuesta aceptada de usar _.findKeyfunciona para objetos con objetos anidados, pero no funciona en esta circunstancia común.

Este enfoque invierte el objeto, intercambiando claves por valores, y luego encuentra la clave buscando el valor en el nuevo objeto (invertido). Si no se encuentra la clave, falsese devuelve, lo cual prefiero undefined, pero podría cambiarlo fácilmente en el tercer parámetro del _.getmétodo 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>

Aquí está mi solución primero:

Por ejemplo, supongo que tenemos un objeto que contiene tres pares de valores:

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

Simplemente podemos escribir una FindKey (matriz, valor) que toma dos parámetros que son un objeto y el valor de la clave que está buscando. Como tal, este método es reutilizable y no necesita iterar manualmente el objeto cada vez pasando solo dos parámetros para esta función.

Métodos ES6 :

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

Normalmente recomiendo lodash en lugar de subrayar.

Si lo tienes, úsalo.

Si no lo hace, debería considerar usar el paquete lodash.invert npm, que es bastante pequeño.

Así es como puedes probarlo con trago:

1) Cree un archivo llamado gulpfile.js con el siguiente contenido:

// 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) Instale el paquete lodash.invert y trague

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

3) Probar que funciona:

$ 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

Referencias

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

https://lodash.com/

Diferencias entre lodash y subrayado

https://github.com/gulpjs/gulp

Subrayar js solución

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}

Esto me funcionó para obtener la clave / valor del objeto.

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

Realmente sencillo.

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"

¡Mantenlo simple!

No necesita filtrar el objeto a través de métodos sofisticados o libs, Javascript tiene una función incorporada llamada Object.values .

Ejemplo:

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

Esto devolverá los datos de propiedad del objeto.

Referencias

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