let people = new Map();
people.set('1', 'jhon');
people.set('2', 'jasmein');
people.set('3', 'abdo');
我想要一种方法，通过其值返回一个键。
let jhonKey = people.getKey('jhon'); // jhonKey should be '1'
for..of循环来直接遍历map.entries并获取键。
function getByValue(map, searchValue) {
for (let [key, value] of map.entries()) {
if (value === searchValue)
return key;
}
}
let people = new Map();
people.set('1', 'jhon');
people.set('2', 'jasmein');
people.set('3', 'abdo');
console.log(getByValue(people, 'jhon'))
console.log(getByValue(people, 'abdo'))var更改为const。 - Keithlet 而不是 const。 - Rajeshmap.entries()，因为 map 本身就可以作为迭代器。我已经提交了修改。 - philraj[...people.entries()]），并在该数组中搜索它。
你可以将其转换为条目数组（使用[...people.entries()]），并在该数组中搜索它。
let people = new Map();
people.set('1', 'jhon');
people.set('2', 'jasmein');
people.set('3', 'abdo');
let jhonKeys = [...people.entries()]
.filter(({ 1: v }) => v === 'jhon')
.map(([k]) => k);
console.log(jhonKeys); // if empty, no key found otherwise all found keys.|| 逻辑：[...people.values()]。 - philrajArray.from并映射值。 - Nina Scholz{ 1: v } 语法是什么？你是将键值对解构为对象吗？为什么不用 [k, v] 呢？ - philraj虽然已经有很多出色的答案，但你仍可以尝试使用下面的 "..." 和 Array.find ：
let people = new Map();
people.set('1', 'jhon');
people.set('2', 'jasmein');
people.set('3', 'abdo');
function getKey(value) {
return [...people].find(([key, val]) => val == value)[0]
}
console.log('Jasmein - ', getKey('jasmein'))
console.log('Jhon - ', getKey('jhon')) 在使用 JavaScript Map 时，我喜欢 Nitish 的回答：（链接）
const map = new Map([
[1, 'one'],
[2, 'two'],
[3, 'three'],
]);
function getKey(val) {
return [...map].find(([key, value]) => val === value)[0];
}
console.log(getKey('one')); // 1
console.log(getKey('two')); // 2
console.log(getKey('three')); // 3对于JavaScript对象，您可以这样做：
const map = {
1: 'one',
2: 'two',
3: 'three',
};
function getKey(val) {
return Object.keys(map).find(key => map[key] === val);
}
console.log(getKey('one')); // 1
console.log(getKey('two')); // 2
console.log(getKey('three')); // 3[...map].find(([key, value]) => val === value)?.[0]。 - keymap在这个方向上没有直接的选择信息的方法，所以如果你只有地图，需要像其他人建议的一样遍历整个集合。
如果 map/array/other 足够大，这样的循环会影响性能，并且反向查找的要求在项目中很常见，那么您可以使用一对 map/array/other 实现自己的结构，其中一个是按当前对象排序，另一个将键和值反转。
这样，反向查找与正常查找一样高效。当然，你需要做更多的工作，因为你需要实现每个方法，使其通过一个或两个基础对象传递，所以如果 map 很小和/或反向查找不经常使用，扫描-通过循环选项可能更可取，因为它更简单维护和可能更容易优化 JiT 编译器。
无论如何，需要注意的一件事是，多个键可能具有相同的值。如果可能出现这种情况，那么在遍历 map 时，您需要决定是否可以任意返回可能的键（可能是第一个）或者是否要返回一组键。而且如果为可能具有重复值的数据实现反向索引，也需要考虑相同的问题。
这里是一个正确类型化的Typescript解决方案，不会不必要地创建数组。
function find_map_value<K, V>(m: Map<K, V>, predicate: (v: V) => boolean): [K, V] | undefined {
for (const [k, v] of m) {
if (predicate(v)) {
return [k, v];
}
}
return undefined;
}
如果你想获取所有值，可以使用生成器：
function* find_all_map_values<K, V>(m: Map<K, V>, predicate: (v: V) => boolean): Generator<[K, V]> {
for (const [k, v] of m) {
if (predicate(v)) {
yield [k, v];
}
}
}
return更改为yield并相应地更新返回类型。 - Timmmm可以将Map反转，使键变为值，值变为键，然后将原始值作为键查找。以下是一个示例：
let myMap = new Map([
[1, 'one'],
[2, 'two'],
[3, 'three'],
]);
let invertedMap = new Map([...myMap.entries()].map(
([key, value]) => ([value, key]))
);
console.log(invertedMap.get('one'))
// => 1
invertedMap 也将反映最后一个重复值的值。 - IliasTiterator 原型/实例引用 查找目标值呢？将其注入到原型链/填充解决方案可以使其在代码中通用。
Map.prototype.getKey = function(targetValue){
let iterator = this[Symbol.iterator]()
for (const [key, value] of iterator) {
if(value === targetValue)
return key;
}
}
const people = new Map();
people.set('1', 'jhon');
people.set('2', 'jasmein');
people.set('3', 'abdo');
const jhonKey = people.getKey('jhon');
console.log(`The key for 'jhon' is: ${jhonKey}`);for..of来迭代可迭代对象。如果需要，可以简写为for(const [key, value] of this){...}。class ReferenceMap {
#left = new Map();
#right = new Map();
constructor(iterable = []) {
this.#left = new Map(iterable);
this.#right = new Map(ReferenceMap.swapKeyValues(iterable));
}
has(key) {
return this.#left.has(key) || this.#right.has(key);
}
get(key) {
return this.#left.has(key) ? this.#left.get(key) : this.#right.get(key);
}
set(key, value) {
this.#left.set(key, value);
this.#right.set(value, key);
}
delete(key) {
if (this.#left.has(key)) {
let ref = this.#left.get(key);
this.#left.delete(key);
this.#right.delete(ref);
} else if (this.#right.has(key)) {
let ref = this.#right.get(key);
this.#right.delete(key);
this.#left.delete(ref);
}
}
entries() {
return this.#left.entries();
}
keys() {
return this.#left.keys();
}
values() {
return this.#left.values();
}
[Symbol.iterator]() {
return this.entries();
}
get size() {
return this.#left.size;
}
static * swapKeyValues(entries) {
for (let [key, value] of entries) yield [value, key];
}
}
这个问题有点不正确，因为一个值可以分配给多个键。因此，对于给定的值，结果应该是一个键数组（而不是单个键）。如果您经常进行这样的搜索，可以使用以下缓存生成器进行反向映射。
let genRevMapCache = map => [...map.entries()].reduce((a,[k,v]) => {
if(!a.get(v)) a.set(v,[]);
a.get(v).push(k);
return a;
}, new Map() );
let genRevMapCache = map => [...map.entries()].reduce((a,[k,v]) => {
if(!a.get(v)) a.set(v,[]);
a.get(v).push(k);
return a;
}, new Map() );
// TEST
let people = new Map();
people.set('1', 'jhon');
people.set('2', 'jasmein');
people.set('3', 'abdo');
people.set('4', 'jhon');
let cache = genRevMapCache(people);
console.log('jasmein', cache.get('jasmein'));
console.log('jhon', cache.get('jhon'));