How can I get a key in a JavaScript 'Map' by its value?

Question

I have a JavaScript 'Map' like this one

let people = new Map();
people.set('1', 'jhon');
people.set('2', 'jasmein');
people.set('3', 'abdo');

I want some method to return a key by its value.

let jhonKey = people.getKey('jhon'); // jhonKey should be '1'

Answer 1

what I ended up doing to make it O(1) in all cases

class ClientService {
  private readonly clientMap = new Map<number, Client[]>();
  private readonly userMap = new Map<Client, number>();

  addClient(userId: number, client: Client) {
    const existingClients = this.clientMap.get(userId) ?? [];
    existingClients.push(client);
    this.clientMap.set(userId, existingClients);
    this.userMap.set(client, userId);
  }

  removeClient(client: Client) {
    const userId = this.userMap.get(client);

    if (!userId) {
      return;
    }

    this.userMap.delete(client);

    const existingClients = this.clientMap.get(userId);

    if (!existingClients) {
      return;
    }

    if (existingClients.length === 1) {
      this.clientMap.delete(userId);
    } else {
      // I know filter isn't O(1), but in my case I know it will be usually 1 and in general less than 5, you can user a better data structure here if in other case it can grow
      const newClients = existingClients.filter(
        (c) => client !== c,
      );
      this.clientMap.set(userId, newClients);
    }
  }

  getClients(userId: number): Client[] {
    const clients = this.clientMap.get(notification.userId) ?? [];
  }
}

Answer 2

JavaScript Map and Object

Given a JavaScript Map, I like Nitish's answer:

// JavaScript Map

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

For a JavaScript object, you could do something like this:

// JavaScript Object

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

Answer 3

Though late and other great answers already exist, still you can give the below "..." and Array.find a try:

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

Answer 4

Cache

The question is a bit wrong because one value can be assigned to many keys. Therefore, the result for a given value should be an array of keys (not a single key). If you want to oftet make such search you can use following cache generator for reverse 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() );

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

Answer 5

Tailing off what Maciej Krawczyk suggested here is a general circular map implementation for that.

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

Answer 6

Here is a properly typed Typescript solution that doesn't unnecessarily create an array.

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

If you want all values you can use a generator:

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

Answer 7

Why not simply make use of map's built in iterator prototype/instance reference looking for the target value? Injection into the prototype chain/polyfill inspired solution of sorts makes it universal to ones code:

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 anyone curious why I added yet another answer. Most of these answers (exception, I like Rajesh's answer, but I added to the prototype chain) are doing a lot of data duplication in the name of finding a value by using the spread operator or even straight up crafting Arrays. Object.keys() mind you is also terribly nonperformant.

Note, I use for..of which iterates on iterables. One could do short hand simply with for(const [key, value] of this){...} if desired.

Answer 8

JS:

// Returns keys for all instances
function findAll(obj) {
  return Array.from(items.keys()).map(k => items.get(k) === obj ? k : undefined).filter(k => k);
}

// Returns keys for the first instances
function findFirst(obj) {
  return Array.from(items.keys()).find(k => items.get(k) === obj);
}

Typescript:

protected items = new Map<TKey, TObject>();

public findAll(obj: TObject): Array<TKey> {
  return Array.from(this.items.keys()).map(k => this.items.get(k) === obj ? k : undefined).filter(k => !!k);
}

public findFirst(obj: TObject): TKey | undefined {
  return Array.from(this.items.keys()).find(k => this.items.get(k) === obj);
}

---

Explanation:

// Gets the keys as an array
Array.from(this.items.keys())

// Map the keys whose object matches the instance of `obj` to the key itself, undefined otherwise
.map(k => this.items.get(k) === obj ? k : undefined)

// Filter out array elements that are undefined
// (!! is for strict type-checking/readability practices, you can simply use k => k)
.filter(k => !!k)

// Finds the first occurrence of the key for the given object, undefined if not found
.find(k => this.items.get(k) === obj)

Answer 9

My TypeScript version:

const getByValue = <A, B>(m: Map<A,B>, searchValue: B):[A, B] | undefined => {
  const l:IterableIterator<[A, B]> = m.entries();
  const a:[A, B][] = Array.from(l);
  return a.find(([_k,v]) => v === searchValue);
}

Answer 10

There isn't any direct method for picking out information in this direction, so if all you have is the map you need to loop through the set as suggested by others.

If the map/array/other is large enough that such a loop would be a performance issue and the requirement for a reverse lookup is common within the project, you could implement your own structure using a pair of maps/arrays/other with one as per the current object and the other with the key and value reversed.

That way, the reverse lookup is as efficient as the normal one. Of course, you have more work to do as you need to implement each method that you need as a pass-through to one or both of the underlying objects so if the map is small and/or the reverse lookup is not needed often the scan-via-loop option is likely to be preferable due to being simpler to maintain and possible simpler for the JiT compiler to optimise.

In any case, one thing to be wary of is the possibility that multiple keys could have the same value. If this is possible then when looping through your map you need to decide if you are fine to return one of the possible keys arbitrarily (probably the first one) or if you want to return an array of keys, and if implementing a reverse index for data that could have duplicate values the same issue also needs to be accounted for.

Answer 11

You can use a for..of loop to loop directly over the map.entries and get the keys.

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

Answer 12

You could convert it to an array of entries (using [...people.entries()]) and search for it within that array.

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.

Answer 13

One could invert the Map so that the keys are the values and the values are the keys and then lookup the original value as a key. Here's an example:

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