Question

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

Answer 1

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

Answer 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之外使用此功能，并将对象传递给它。

Answer 3

使用Underscore.js库：

var hash = {
 foo: 1,
 bar: 2
};

(_.invert(hash))[1]; // => 'foo'

Answer 4

如上所述，需要迭代。例如，在现代浏览器中，您可以：

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

Answer 5

lodash方式https://lodash.com/docs#findKey

＆＃13;

var users = {
  'barney':  { 'age': 36, 'active': true },
  'fred':    { 'age': 40, 'active': false },
  'pebbles': { 'age': 1,  'active': true }
};

_.findKey(users, { 'age': 1, 'active': true });
// → 'pebbles'

＆＃13;

Answer 6

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

Answer 7

我使用此功能：

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

Answer 8

保持原型清洁。

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

Answer 9

如果您使用下划线或 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'

Answer 10

不可迭代的解决方案

主要功能：

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"

Answer 11

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

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

Answer 12

ES6 +一班轮船

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

或

let key = Object.keys(obj)[Object.values(obj).indexOf(value)];

或

let key = ( Object.entries(obj).find(([k,v])=>v===value) || [] )[0];

Answer 13

没有看到以下内容：

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)

Answer 14

如果您有一个带有数组值的对象。这是一个很好的例子。让我们假设您想根据您拥有的文件的扩展名显示一个图标。具有相同图标的所有扩展都属于相同的对象值。

<块引用>

注意：将这里的案例包装在一个对象中比在很多案例中进行切换要好。

检查下面的代码片段（用 es6 编写），了解我们如何返回特定扩展程序的特定密钥。

我从这个 git repo 获得了扩展列表

// Oject that contains different icons for different extentions
const icons = {
    "music": ["mp3", "m4a", "ogg", "acc", "flac","m3u", "wav"],
    "video": ["mp4","webm", "mkv", "avi", "mov", "m4v", "mpeg"],
    "image": ["jpg", "gif", "png", "jpeg", "tif", "psd", "raw", "ico"],
    "archives": ["zip", "rar", "tar", "dmg", "jar"],
    "3d-files": ["3ds", "dwg", "obj", "dae", "skp", "fbx"],
    "text": ["doc", "rtf", "txt", "odt", "tex"],
    "vector-graphics":["ai", "svg"],
    "pdf": ["pdf"],
    "data": ["xml", "csv", "xls"]
}

const get_icon_Key =( icons_object,file_extention) => {
   // For each key we chack if the value is contained in the list of values
   let key = Object.keys(icons_object).find(
    k=> icons[k].find(
            // At this leve we check if the extention exist in the array of the specific object value ie. 'music', 'video' ...
            icons_ext => icons_ext === file_extention)  
            // if we find it means this is the key we are looking for
            ? true: false);
    return key
}

console.log(`The icon of for mp3 extention is: => ${get_icon_Key(icons,"mp3")}`)
console.log(`The icon of for mp4 extention is: => ${get_icon_Key(icons,"mp4")}`)

Answer 15

由于值是唯一的，因此应该可以将值作为附加键集添加。这可以通过以下快捷方式完成。

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"

这确实假设键和值之间没有共同的元素。

Answer 16

或者，更简单 - 使用您想要的顺序创建一个具有键和值的新对象，然后查看该对象。我们使用上面的原型代码进行了冲突。您不必在键周围使用String函数，这是可选的。

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

Answer 17

好像这个问题没有被打成纸浆......

这是一个只是因为它带给你的好奇心......

如果你确定你的对象只有字符串值，你真的可以用尽自己来实现这个实现：

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

也许在这里建立一些有用的东西......

希望这会让你感到高兴。

Answer 18

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

要使用第一个值（例如output={"x":"a","y":"b"}）： output=Object.keys(input).reduceRight(function(accum,key,i){accum[input[key]]=key;return accum;},{})

要使用最后一个值（例如output={"x":"c","y":"b"}）： output=Object.keys(input).reduce(function(accum,key,i){accum[input[key]]=key;return accum;},{})

获取每个值的键数组（例如output={"x":["c","a"],"y":["b"]}）： output=Object.keys(input).reduceRight(function(accum,key,i){accum[input[key]]=(accum[input[key]]||[]).concat(key);return accum;},{})

Answer 19

这是一个适用于平键的Lodash解决方案=＆gt;值对象，而不是嵌套对象。接受的答案建议使用_.findKey适用于具有嵌套对象的对象，但在这种常见情况下它不起作用。

此方法反转对象，交换值的值，然后通过查找新（反转）对象上的值来查找键。如果找不到该密钥，则会返回false，而不是undefined，但您可以轻松地将其替换为_.get方法的第三个参数getKey() 1}}。

＆＃13;

// 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' ) + '"' );

＆＃13;

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js"></script>

＆＃13;

Answer 20

非常简单。

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"

Answer 21

这首先是我的解决方法：

例如，我假设我们有一个包含三个值对的对象：

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（array，value），这两个参数是对象和要查找的键的值。因此，此方法是可重用的，并且您不需要每次仅通过为此函数传递两个参数来手动迭代对象。

Answer 22

我通常建议使用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包和gulp

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

Differences between lodash and underscore

https://github.com/gulpjs/gulp

Answer 23

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

Answer 24

这对于我获取对象的键/值很有用。

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

Answer 25

这是Underscorejs方法的一个小扩展，并使用 Lodash 代替：

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

FindKey将search and return the first key与该值匹配如果您想要最后一场比赛，请改用FindLastKey。

Answer 26

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

Answer 27

ES6 方法：

stop_signal

Answer 28

我知道我迟到了，但是您如何看待我今天制作的这个 EMCMAScript 2017 解决方案？它处理多个匹配，因为如果两个键具有相同的值会发生什么？这就是我创建这个小片段的原因。

当有一个匹配时，它只返回一个字符串，但当有多个匹配时，它返回一个数组。

let object = { nine_eleven_was_a_inside_job: false, javascript_isnt_useful: false }

// Complex, dirty but useful. Handle mutiple matchs which is the main difficulty.
Object.prototype.getKeyByValue = function (val) {
  
  let array = [];
  let array2 = [];
  
  // Get all the key in the object.
  for(const [key] of Object.entries(this)) {
    if (this[key] == val) {
      // Putting them in the 1st array.
      array.push(key)
    }
  }
  
  // List all the value of the 1st array.
  for(key of array) {
    // "If one of the key in the array is equal to the value passed in the function (val), it means that 'val' correspond to it."
    if(this[key] == val) {
      // Push all the matchs. 
      array2.push(key);
    }
  }
  
  // Check the lenght of the array.
  if (array2.length < 2) {
    // If it's under 2, only return the single value but not in the array. 
    return array2[0];
  } else {
    // If it's above or equal to 2, return the entire array.
    return array2; 
  }
}

/*

Basic way to do it wich doesn't handle multiple matchs.

let getKeyByValue = function (object, val) {
  for(const [key, content] of Object.entries(object)) {
    if (object[key] === val) {
      return key
    }
  }
}
*/

console.log(object.getKeyByValue(false))

Answer 29

保持简单！

您不需要通过复杂的方法或库来过滤对象，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

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

29 个答案:

好像这个问题没有被打成纸浆......