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

如果你正在使用 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'

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

在这两个方向上，键值映射的检索速度都非常快。在内部没有昂贵的对象/数组遍历，因此平均访问时间不受数据大小的影响而保持恒定。

这对我获取对象的键/值有效。

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

给定 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)

由于这些值是唯一的，因此将其作为附加密钥集添加应该是可能的。这可以通过以下简便方式完成。

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"

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

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

FindKey将搜索并返回第一个与该值匹配的键。
如果您想要最后一个匹配项，请改用FindLastKey。

ES6 方法：

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

以下是我的解决方案：

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

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)函数，它接收两个参数，一个是对象，另一个是你要查找的键的值。这样，该方法具有可重用性，你不需要每次手动迭代对象，只需传递两个参数即可使用该函数。