如何通过JavaScript对象的值获取该对象中的键？

我有一个非常简单的JavaScript对象，我使用它作为关联数组。是否有一个简单的函数允许我获取值的键，或者我必须迭代对象并手动查找它？

没有可用的标准方法。您需要迭代，并可以创建一个简单的帮助器：

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

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'

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
}

---

我使用这个函数：

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

用法：

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 a=新数组（）；
a、 推动（{“1”：“苹果”，“2”：“香蕉”}）；
a、 推（{“3”：“椰子”，“4”：“芒果”}）；
GetIndexByValue（一种“椰子”）；
函数GetIndexByValue（arrayName，value）{
var-keyName=“”；
var指数=-1；
对于（var i=0；i

或者，更简单的方法是，按照您想要的顺序创建一个带有键和值的新对象，然后查找该对象。我们在使用上述原型代码时遇到了冲突。您不必在键周围使用String函数，这是可选的

 newLookUpObj = {};
 $.each(oldLookUpObj,function(key,value){
        newLookUpObj[value] = String(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"

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

这假定键和值之间没有公共元素。

对于库：

---

这是下划线JS方法的一个小扩展，使用Lodash：

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

将显示与该值匹配的值。
如果您想要最后一个匹配，请改用。

我创建了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"

检索键值映射在两个方向上都同样快速。在引擎盖下没有代价高昂的对象/数组遍历，因此无论数据大小如何，平均访问时间都保持不变

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

ES6，没有原型突变或外部库

例如

函数getKeyByValue（对象，值）{ 返回Object.keys（Object.find）（key=>Object[key]==value）； } 常量映射={“第一个”：“1”，“第二个”：“2”}；

---

log（getKeyByValue（map，“2”））我通常建议使用lodash而不是下划线

如果你有，就用它

如果你不这样做，那么你应该考虑使用Load .Nut.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);
});

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

参考资料

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

给定的

输入={“a”：“x”，“b”：“y”，“c”：“x”}

• 使用第一个值（例如，

  输出={“x”：“a”，“y”：“b”}

  ）：

输入={
“a”：“x”，
“b”：“y”，
“c”：“x”
}
输出=对象。按键（输入）。还原灯（功能（累计，按键，i）{
累计[输入[键]]=键；
返回累计；
}, {})
console.log（输出）

如果您使用的是下划线或Lodash库，则可以使用以下功能：

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

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'

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用户={
“barney”：{“年龄”：36，“活跃”：真}，
“fred”：{“年龄”：40，“活跃”：假}，
'pebbles'：{'age'：1，'active'：true}
};
_.findKey（用户，函数（o）{返回o.age<40；}）；
//=>“barney”（不保证迭代顺序）
//“\.匹配”iteratee速记。
_.findKey（用户，{'age'：1，'active'：true}）；
//=>“鹅卵石”
//“\uuu.matchesProperty”迭代速记。
_.findKey（用户，['active'，false]）；
//=>“弗雷德”
//“\.property”iteratee速记。
_.findKey（用户，“活动”）；
//=>“巴尼”

保持原型的清洁

例如：

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

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

洛达斯之路

var用户={
“barney”：{“年龄”：36，“活跃”：真}，
“fred”：{“年龄”：40，“活跃”：假}，
'pebbles'：{'age'：1，'active'：true}
};
_.findKey（用户，{'age'：1，'active'：true}）；
// → '鹅卵石“

用于闭包编译器提取编译后未知的密钥名

更性感的版本，但使用未来的

对象。条目

功能

好像这个问题还没有被打成一团。。。 这里有一个只是为了满足你的好奇心

如果您确信您的对象将只有字符串值，那么您可能真的会耗尽自己的精力想出以下实现：

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

也许这里有一些有用的东西可以建造

希望这能让你开心

不可迭代的解决方案

主要功能：

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

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'

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
}

Ob

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

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

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

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