Как получить ключ в объекте JavaScript по его значению?

У меня есть довольно простой объект JavaScript, который я использую в качестве ассоциативного массива. Существует ли простая функция, позволяющая мне получить ключ для значения, или мне нужно выполнить итерацию объекта и найти его вручную?

С библиотекой 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, нет прототипов мутаций или внешних библиотек.

Пример,

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


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

Стандартный метод недоступен. Вам нужно повторить, и вы можете создать простой помощник:

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'

Одно слово предостережения : даже если вышеперечисленное работает, это вообще плохая идея расширить любой хост или нативный объект .prototype. Я сделал это здесь, потому что это очень хорошо подходит для этого вопроса. В любом случае, вам, вероятно, следует использовать эту функцию вне .prototypeи вместо нее передать объект.

Как сказано, итерация необходима. Например, в современном браузере вы можете иметь:

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

куда value содержит значение, которое вы ищете. Сказал, что я, вероятно, использовал бы цикл.

В противном случае вы можете использовать правильный объект "hashmap" - в JS есть несколько реализаций - или реализовать его самостоятельно.

ОБНОВЛЕНИЕ 2018

Прошло шесть лет, но я все еще получил немного голосов здесь, поэтому я чувствую, что более современное решение - для современного браузера / среды - должно быть упомянуто в самом ответе, а не только в комментариях:

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

Конечно, это также может быть функция:

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

Лодаш путь 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)];
}

Сделано для закрытия компилятора, чтобы извлечь имя ключа, который будет неизвестен после компиляции

Более сексуальная версия, но использующая будущее Object.entries функции

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

ES6 + один вкладыш

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

Вернуть все ключи со значением:

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

Я использую эту функцию:

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

Применение:

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

Не повторяемое решение

Основная функция:

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
}

Объект с ключами и значениями:

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

Тестовое задание:

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

Держите ваш прототип в чистоте.

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

Пример:

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

Если вы работаете с библиотекой Underscore или Lodash , вы можете использовать функцию _.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'

Я создал библиотеку bimap ( https://github.com/alethes/bimap ), которая реализует мощный, гибкий и эффективный интерфейс двунаправленной карты JavaScript. Он не имеет зависимостей и может использоваться как на стороне сервера (в Node.js вы можете установить его с помощью npm install bimap), так и в браузере (по ссылке на lib / bimap.js). ).

Основные операции действительно просты:

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"

Поиск соответствия ключ-значение одинаково быстр в обоих направлениях. Под капотом нет дорогостоящих обходов объектов / массивов, поэтому среднее время доступа остается постоянным независимо от размера данных.

не увидел следующее:

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)

Поскольку значения уникальны, должна быть возможность добавить значения в качестве дополнительного набора ключей. Это можно сделать с помощью следующего ярлыка.

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

Это позволит получить либо ключ, либо значение:

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

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

Это предполагает, что между ключами и значениями нет общих элементов.

Учитывая input={"a":"x", "b":"y", "c":"x"}...

• Чтобы использовать первое значение (например 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)

• Чтобы использовать последнее значение (например 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)

• Чтобы получить массив ключей для каждого значения (например 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;
    } 

Или еще проще - создайте новый объект с ключами и значениями в нужном вам порядке, а затем посмотрите на этот объект. У нас были конфликты с использованием прототипов кодов выше. Вам не нужно использовать функцию String вокруг клавиши, это необязательно.

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

Это небольшое расширение метода Underscorejs, и вместо него используется Lodash :

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

FindKey будет искать и возвращать первый ключ, который соответствует значению.
Если вы хотите использовать последнее совпадение, используйтевместо него FindLastKey .

Как будто этот вопрос не был избит до полусмерти ...

Вот один только для любопытства это приносит вам ...

Если вы уверены, что ваш объект будет иметь только строковые значения, вы действительно можете исчерпать себя, чтобы вызвать в воображении эту реализацию:

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

Может быть, здесь есть что-то полезное ...

Надеюсь, это вас забавляет.

Вот решение Lodash, которое работает для плоского ключа => объекта значения, а не для вложенного объекта. Принятый ответ предлагает использовать _.findKeyработы для объектов с вложенными объектами, но он не работает в этом обычном случае.

Этот подход инвертирует объект, меняя ключи на значения, а затем находит ключ, просматривая значение нового (инвертированного) объекта. Если ключ не найден, то falseвозвращается, что я предпочитаю undefined, но вы можете легко поменять его в третьем параметре _.getметода в 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>

Вот мое решение в первую очередь:

Например, я предполагаю, что у нас есть объект, который содержит три пары значений:

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

Мы можем просто написать findKey (массив, значение), который принимает два параметра, которые являются объектом и значением ключа, который вы ищете. Таким образом, этот метод можно использовать повторно, и вам не нужно каждый раз вручную повторять объект, передавая только два параметра для этой функции.

ES6 методы:

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

Я обычно рекомендую lodash, а не подчеркивание.

Если у вас есть, используйте его.

Если вы этого не сделаете, то вам следует рассмотреть возможность использования пакета lodash.invert npm, который довольно крошечный.

Вот как вы можете проверить это, используя gulp:

1) Создайте файл с именем gulpfile.js со следующим содержимым:

// 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) Установите пакет lodash.invert и проглотите

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

3) Проверьте, что это работает:

$ 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

Ссылки

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

https://lodash.com/

Различия между lodash и подчеркиванием

https://github.com/gulpjs/gulp

Подчеркни 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}

это сработало для меня, чтобы получить ключ / значение объекта.

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

Действительно просто.

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"

Будь проще!

Вам не нужно фильтровать объект с помощью сложных методов или библиотек, Javascript имеет встроенную функцию под названием Object.values .

Пример:

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

Это вернет данные свойства объекта.

Ссылки

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