Como obter uma chave em um objeto JavaScript por seu valor?

Eu tenho um objeto JavaScript bastante simples, que eu uso como uma matriz associativa. Existe uma função simples que me permita obter a chave de um valor ou preciso iterar o objeto e descobri-lo manualmente?

Com a 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, sem mutações de protótipo ou bibliotecas externas.

Exemplo,

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


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

Nenhum método padrão disponível. Você precisa iterar e pode criar um auxiliar simples:

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'

Uma palavra de cautela : Mesmo que as opções acima funcionem, geralmente é uma má idéia estender qualquer host ou objeto nativo .prototype. Fiz aqui porque se encaixa muito bem no problema. De qualquer forma, você provavelmente deve usar essa função fora do .prototypee passar o objeto para ele.

Como dito, a iteração é necessária. Por exemplo, no navegador moderno, você pode ter:

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

Onde valuecontém o valor que você está procurando. Disse que eu provavelmente usaria um loop.

Caso contrário, você poderá usar um objeto "hashmap" adequado - existem várias implementações no JS ao redor - ou implementar por conta própria.

ATUALIZAÇÃO 2018

Seis anos se passaram, mas ainda recebo voto aqui, então sinto que uma solução mais moderna - para navegador / ambiente moderno - deve ser mencionada na resposta em si e não apenas nos comentários:

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

Claro que também pode ser uma função:

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

A maneira 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)];
}

Feito para o compilador de fechamento para extrair o nome da chave que será desconhecido após a compilação

Versão mais sexy, mas usando a Object.entriesfunção 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);

Retorne todas as chaves com o valor:

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

Eu uso esta função:

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

Solução não iterável

Função 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 com chaves e valores:

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

Teste:

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

Mantenha seu protótipo limpo.

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

Exemplo:

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

Se você estiver trabalhando com a biblioteca Underscore ou Lodash , poderá usar a função _.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'

Criei a biblioteca bimap ( https://github.com/alethes/bimap ) que implementa uma interface de mapa bidirecional JavaScript poderosa, flexível e eficiente. Ele não possui dependências e é utilizável no servidor (no Node.js, você pode instalá-lo npm install bimap) e no navegador (vinculando-se a lib / bimap.js ).

As operações básicas são 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"

A recuperação do mapeamento de valores-chave é igualmente rápida nas duas direções. Não há travessias caras de objetos / matrizes sob o capô, portanto o tempo médio de acesso permanece constante, independentemente do tamanho dos dados.

não viu o seguinte:

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 os valores são únicos, deve ser possível adicionar os valores como um conjunto adicional de chaves. Isso pode ser feito com o seguinte atalho.

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

Isso permitiria a recuperação por meio da chave ou do valor:

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

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

Isso pressupõe que não há elementos comuns entre as chaves e os valores.

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

• Para usar o primeiro valor (por exemplo 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 o último valor (por exemplo 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 obter uma matriz de chaves para cada valor (por exemplo 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, mais fácil ainda - crie um novo objeto com as chaves e os valores na ordem que você deseja e, em seguida, procure esse objeto. Tivemos conflitos usando os códigos de protótipo acima. Você não precisa usar a função String ao redor da tecla, isso é opcional.

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

Esta é uma pequena extensão do método Underscorejs e usa o Lodash :

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

FindKey irá procurar e retornar a primeira chave que corresponde ao valor.
Se você deseja a última correspondência, use FindLastKey .

Como se essa pergunta não tivesse sido derrotada ...

Aqui está um apenas para qualquer curiosidade que isso traz a você ...

Se você tem certeza de que seu objeto terá apenas valores de sequência, você pode realmente se cansar de conjurar esta implementação:

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

Talvez haja algo útil para construir daqui ...

Espero que isso diverte você.

Aqui está uma solução Lodash para isso que funciona para o objeto chave => value, em vez de um objeto aninhado. A sugestão da resposta aceita de usar_.findKey funciona para objetos com objetos aninhados, mas não funciona nessa circunstância comum.

Essa abordagem inverte o objeto, trocando chaves por valores e, em seguida, localiza a chave pesquisando o valor no novo objeto (invertido). Se a chave não for encontrada, falseserá retornada, o que eu prefiro undefined, mas você pode facilmente trocá-la no terceiro parâmetro do_.get mé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>

Aqui está a minha solução primeiro:

Por exemplo, suponho que tenhamos um objeto que contenha três 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

Podemos simplesmente escrever uma findKey (matriz, valor) que aceita dois parâmetros que são um objeto e o valor da chave que você está procurando. Como tal, esse método é reutilizável e você não precisa iterar manualmente o objeto todas as vezes passando apenas dois parâmetros para esta função.

Métodos ES6 :

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

Eu normalmente recomendo lodash em vez de sublinhado.

Se você tiver, use-o.

Caso contrário, considere usar o pacote lodash.invert npm, que é bem pequeno.

Veja como você pode testá-lo usando gulp:

1) Crie um arquivo chamado gulpfile.js com o seguinte conteúdo:

// 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 o pacote lodash.invert e gulp

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

3) Teste se 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

Referências

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

https://lodash.com/

Diferenças entre lodash e sublinhado

https://github.com/gulpjs/gulp

Sublinhar a solução 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}

isso funcionou para eu obter a chave / valor do 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 simples.

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"

Mantenha simples!

Você não precisa filtrar o objeto por métodos ou bibliotecas sofisticados, o Javascript possui uma função integrada chamada Object.values .

Exemplo:

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

Isso retornará os dados da propriedade do objeto.

Referências

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