How to get a key in a JavaScript object by its value?

Question

I have a quite simple JavaScript object, which I use as an associative array. Is there a simple function allowing me to get the key for a value, or do I have to iterate the object and find it out manually?

Answer 1

function getKeyByValue(object, value) {
  return Object.keys(object).find(key => object[key] === value);
}

ES6, no prototype mutations or external libraries.

Example,

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

No standard method available. You need to iterate and you can create a simple helper:

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'

One word of caution: Even if the above works, its generally a bad idea to extend any host or native object's .prototype. I did it here because it fits the issue very well. Anyway, you should probably use this function outside the .prototype and pass the object into it instead.

Answer 3

As said, iteration is needed. For instance, in modern browser you could have:

var key = Object.keys(obj).filter(function(key) {return obj[key] === value})[0];

Where value contains the value you're looking for. Said that, I would probably use a loop.

Otherwise you could use a proper "hashmap" object - there are several implementation in JS around - or implement by your own.

UPDATE 2018

Six years passed, but I still get some vote here, so I feel like a more modern solution – for modern browser/environment – should be mentioned in the answer itself and not just in the comments:

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

Of course it can be also a function:

const getKeyByValue = (obj, value) => 
        Object.keys(obj).find(key => obj[key] === value);

Answer 4

Shortest One Liners

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

---

Return all keys with the value:

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

---

If value is an Array or Object:

let keys = Object.keys(obj).filter(k=>JSON.stringify(obj[k])===JSON.stringify(value));

Answer 5

With the Underscore.js library:

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

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

Answer 6

The lodash way 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'

Answer 7

function extractKeyValue(obj, value) {
    return Object.keys(obj)[Object.values(obj).indexOf(value)];
}

Made for closure compiler to extract key name which will be unknown after compilation

More sexy version but using future Object.entries function

function objectKeyByValue (obj, val) {
  return Object.entries(obj).find(i => i[1] === val);
}

Answer 8

I use this function:

Object.prototype.getKey = function(value){
  for(var key in this){
    if(this[key] == value){
      return key;
    }
  }
  return null;
};

Usage:

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

Non-iteratable solution

Main function:

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
}

Object with keys and values:

var greetings = {
    english   : "hello",
    ukranian  : "привіт"
};

Test:

keyByValue("привіт");
// => "ukranian"

Answer 10

Keep your prototype clean.

function val2key(val,array){
    for (var key in array) {
        if(array[key] == val){
            return key;
        }
    }
 return false;
}

Example:

var map = {"first" : 1, "second" : 2};
var key = val2key(2,map); /*returns "second"*/

Answer 11

If you are working with Underscore or Lodash library, you can use the _.findKey function:

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 12

I created the bimap library (https://github.com/alethes/bimap) which implements a powerful, flexible and efficient JavaScript bidirectional map interface. It has no dependencies and is usable both on the server-side (in Node.js, you can install it with npm install bimap) and in the browser (by linking to lib/bimap.js).

Basic operations are really simple:

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"

Retrieval of the key-value mapping is equally fast in both directions. There are no costly object/array traversals under the hood so the average access time remains constant regardless of the size of the data.

Answer 13

this worked for me to get key/value of object.

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 14

didn't see the following:

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 15

Since the values are unique, it should be possible to add the values as an additional set of keys. This could be done with the following shortcut.

var foo = {};
foo[foo.apple = "an apple"] = "apple";
foo[foo.pear = "a pear"] = "pear";

This would permit retrieval either via the key or the value:

var key = "apple";
var value = "an apple";

console.log(foo[value]); // "apple"
console.log(foo[key]); // "an apple"

This does assume that there are no common elements between the keys and values.

Answer 16

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

• To use the first value (e.g. 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)

• To use the last value (e.g. 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)

• To get an array of keys for each value (e.g. 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)

Answer 17

This is a small extension to the Underscorejs method, and uses Lodash instead:

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

FindKey will search and return the first key which matches the value.
If you want the last match instead, use FindLastKey instead.

Answer 18

ES6 methods:

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

Answer 19

Here's a Lodash solution to this that works for flat key => value object, rather than a nested object. The accepted answer's suggestion to use _.findKey works for objects with nested objects, but it doesn't work in this common circumstance.

This approach inverts the object, swapping keys for values, and then finds the key by looking up the value on the new (inverted) object. If the key isn't found then false is returned, which I prefer over undefined, but you could easily swap this out in the third parameter of the _.get method in getKey().

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

Answer 20

Here is my solution first:

For example, I suppose that we have an object that contains three value pairs:

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

We can simply write a findKey(array, value) that takes two parameters which are an object and the value of the key you are looking for. As such, this method is reusable and you do not need to manually iterate the object every time by only passing two parameters for this function.

Answer 21

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 22

Or, easier yet - create a new object with the keys and values in the order you want then do look up against that object. We have had conflicts using the prototype codes above. You don't have to use the String function around the key, that is optional.

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

Answer 23

I typically recommend lodash rather than underscore.

If you have it, use it.

If you don't, then you should consider using the lodash.invert npm package, which is pretty tiny.

Here's how you can test it using gulp:

1) Create a file called gulpfile.js with the following contents:

// 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) Install the lodash.invert package and gulp

$ npm i --save lodash.invert && npm install gulp

3) Test that it works:

$ 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

References

https://www.npmjs.com/package/lodash.invert

https://lodash.com/

Differences between lodash and underscore

https://github.com/gulpjs/gulp

Answer 24

As if this question hasn't been beaten to a pulp...

Here's one just for whatever curiosity it brings you...

If you're sure that your object will have only string values, you could really exhaust yourself to conjure up this implementation:

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

Maybe there's something useful to build off of here...

Hope this amuses you.

Answer 25

Underscore js solution

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 26

If you have an object with array values. Here is a good example. Let us suppose you want to show an icon based on the extension of the file you have. All the extensions with the same icon go under the same object value.

Note: wrap the cases here in an object is better than do a switch with a lot of cases.

Check the code snippet below (written in es6) to see how we return the specific key for the specific extension.

I got the list of extensions from this 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 27

Came here (in 2022) looking for a close variation of OP's question. Variation:

How to find an object key based on a value, where keys may hold collections of values?

For this use case, switch from equality (===) to .includes():

const foo = ['a', 'b','c'];
const bar = ['x', 'y', 'z'];
const bat = [2, 5, 'z'];
const obj = {foo: foo, bar: bar, bat: bat};

const findMe = (v) => {
  return Object.keys(obj).filter((k) => obj[k].includes(v))
}

findMe('y') // ['bar']
findMe('z') // ['bar', 'bat']

Answer 28

Really straightforward.

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 29

I know I’m late but what do you think about this EMCMAScript 2017 solution I made today ? It handles multiple matchs because what happens if two keys have the same values ? This is why I created this little snippet.

When there’s one match, it returns just a string but when there are several matchs, it returns an array.

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 30

We can use simple function to get the value passed key something below

const getKeyByValue = (object, value) => Object.keys(object).find(key => object[key] === value)

Answer 31

Keep it simple!

You don't need to filter the object through sophisticated methods or libs, Javascript has a built in function called Object.values.

Example:

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: {}

This will return the object property data.

References

https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/values