我有一个非常简单的JavaScript对象，我将其用作关联数组。是否有一个简单的函数允许我获取值的键，或者我是否必须迭代对象并手动找到它？
答案 0 :(得分：353)
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"));
答案 1 :(得分：168)
没有可用的标准方法。你需要迭代，你可以创建一个简单的帮助器：
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之外使用此功能，并将对象传递给它。
答案 2 :(得分：93)
使用Underscore.js库：
var hash = {
foo: 1,
bar: 2
};
(_.invert(hash))[1]; // => 'foo'
答案 3 :(得分：91)
如上所述，需要迭代。例如，在现代浏览器中，您可以：
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);
答案 4 :(得分：40)
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'
答案 5 :(得分：31)
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);
}
答案 6 :(得分：21)
我使用此功能：
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
答案 7 :(得分：16)
保持 原型 清洁。
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"*/
答案 8 :(得分：15)
如果您使用下划线或 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'
答案 9 :(得分：13)
不可迭代的解决方案
主要功能：
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"
答案 10 :(得分：9)
我创建了 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"
在两个方向上检索键值映射同样快。引擎盖下没有昂贵的对象/数组遍历，因此无论数据大小如何，平均访问时间都保持不变。
答案 11 :(得分：7)
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];
答案 12 :(得分：6)
没有看到以下内容：
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)
答案 13 :(得分：5)
如果您有一个带有数组值的对象。这是一个很好的例子。让我们假设您想根据您拥有的文件的扩展名显示一个图标。具有相同图标的所有扩展都属于相同的对象值。
<块引用>注意：将这里的案例包装在一个对象中比在很多案例中进行切换要好。
检查下面的代码片段（用 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")}`)答案 14 :(得分：3)
由于值是唯一的，因此应该可以将值作为附加键集添加。这可以通过以下快捷方式完成。
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"
这确实假设键和值之间没有共同的元素。
答案 15 :(得分：2)
或者，更简单 - 使用您想要的顺序创建一个具有键和值的新对象，然后查看该对象。我们使用上面的原型代码进行了冲突。您不必在键周围使用String函数，这是可选的。
newLookUpObj = {};
$.each(oldLookUpObj,function(key,value){
newLookUpObj[value] = String(key);
});
答案 16 :(得分：2)
这是一个只是因为它带给你的好奇心......
如果你确定你的对象只有字符串值，你真的可以用尽自己来实现这个实现：
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]);
也许在这里建立一些有用的东西......
希望这会让你感到高兴。
答案 17 :(得分：1)
鉴于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;},{})
答案 18 :(得分：1)
这是一个适用于平键的Lodash解决方案=＆gt;值对象，而不是嵌套对象。接受的答案建议使用_.findKey适用于具有嵌套对象的对象，但在这种常见情况下它不起作用。
此方法反转对象，交换值的值，然后通过查找新（反转）对象上的值来查找键。如果找不到该密钥，则会返回false，而不是undefined，但您可以轻松地将其替换为_.get方法的第三个参数getKey() 1}}。
// 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>
答案 19 :(得分：1)
非常简单。
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"
答案 20 :(得分：1)
这首先是我的解决方法：
例如，我假设我们有一个包含三个值对的对象：
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），这两个参数是对象和要查找的键的值。因此，此方法是可重用的，并且您不需要每次仅通过为此函数传递两个参数来手动迭代对象。
答案 21 :(得分：1)
我通常建议使用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
答案 22 :(得分：1)
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;
}
答案 23 :(得分：1)
这对于我获取对象的键/值很有用。
let obj = {
'key1': 'value1',
'key2': 'value2',
'key3': 'value3',
'key4': 'value4'
}
Object.keys(obj).map(function(k){
console.log("key with value: "+k +" = "+obj[k])
})
答案 24 :(得分：1)
这是Underscorejs方法的一个小扩展，并使用 Lodash 代替：
var getKeyByValue = function(searchValue) {
return _.findKey(hash, function(hashValue) {
return searchValue === hashValue;
});
}
FindKey将search and return the first key与该值匹配 如果您想要最后一场比赛，请改用FindLastKey。
答案 25 :(得分：0)
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}
答案 26 :(得分：0)
ES6 方法：
stop_signal答案 27 :(得分：0)
我知道我迟到了，但是您如何看待我今天制作的这个 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))答案 28 :(得分：-2)
保持简单！
您不需要通过复杂的方法或库来过滤对象，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