Bagaimana cara mendapatkan kunci dalam objek JavaScript berdasarkan nilainya?

Saya memiliki objek JavaScript yang cukup sederhana, yang saya gunakan sebagai array asosiatif. Apakah ada fungsi sederhana yang memungkinkan saya untuk mendapatkan kunci untuk suatu nilai, atau apakah saya harus mengulangi objek dan menemukannya secara manual?

Dengan perpustakaan Underscore.js :

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

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

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

ES6, tidak ada mutasi prototipe atau perpustakaan eksternal.

Contoh,

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


const map = {"first" : "1", "second" : "2"};
console.log(getKeyByValue(map,"2"));

Tidak ada metode standar yang tersedia. Anda perlu mengulang dan Anda dapat membuat pembantu sederhana:

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'

Satu kata peringatan : Sekalipun di atas berfungsi, umumnya merupakan ide yang buruk untuk memperpanjang host atau objek asli .prototype. Saya melakukannya di sini karena sangat cocok dengan masalah ini. Bagaimanapun, Anda mungkin harus menggunakan fungsi ini di luar .prototypedan meneruskan objek ke dalamnya.

Seperti yang dikatakan, iterasi diperlukan. Misalnya, di browser modern Anda dapat memiliki:

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

Di mana valueberisi nilai yang Anda cari. Mengatakan itu, saya mungkin akan menggunakan loop.

Kalau tidak, Anda bisa menggunakan objek "hashmap" yang tepat - ada beberapa implementasi di sekitar JS - atau diimplementasikan oleh Anda sendiri.

PEMBARUAN 2018

Enam tahun berlalu, tapi saya masih mendapatkan suara di sini, jadi saya merasa seperti solusi yang lebih modern - untuk browser / lingkungan modern - harus disebutkan dalam jawaban itu sendiri dan bukan hanya di komentar:

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

Tentu saja itu bisa juga fungsi:

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

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

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

Dibuat untuk kompilator penutupan untuk mengekstrak nama kunci yang tidak akan diketahui setelah kompilasi

Versi yang lebih seksi tetapi menggunakan Object.entriesfungsi masa depan

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

ES6 + One Liners

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

Kembalikan semua kunci dengan nilai:

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

Saya menggunakan fungsi ini:

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

Pemakaian:

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

Solusi yang tidak dapat diperbaiki

Fungsi utama:

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
}

Objek dengan kunci dan nilai:

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

Uji:

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

Jaga prototipe Anda tetap bersih.

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

Contoh:

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

Jika Anda bekerja dengan Underscore atau Lodash library, Anda dapat menggunakan fungsi _.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'

Saya membuat perpustakaan bimap ( https://github.com/alethes/bimap ) yang mengimplementasikan antarmuka peta dua arah JavaScript yang kuat, fleksibel, dan efisien. Ia tidak memiliki dependensi dan dapat digunakan baik di sisi server (di Node.js, Anda dapat menginstalnya dengan npm install bimap) maupun di browser (dengan menautkan ke lib / bimap.js ).

Operasi dasar sangat sederhana:

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"

Pengambilan pemetaan nilai-kunci sama cepatnya di kedua arah. Tidak ada traversal objek / array yang mahal di bawah kap sehingga waktu akses rata-rata tetap konstan terlepas dari ukuran data.

tidak melihat yang berikut:

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)

Karena nilai-nilai itu unik, harus dimungkinkan untuk menambahkan nilai-nilai sebagai seperangkat kunci tambahan. Ini bisa dilakukan dengan cara pintas berikut.

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

Ini akan memungkinkan pengambilan baik melalui kunci atau nilainya:

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

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

Ini mengasumsikan bahwa tidak ada elemen umum antara kunci dan nilai.

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

• Untuk menggunakan nilai pertama (mis. 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)

• Untuk menggunakan nilai terakhir (mis. 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)

• Untuk mendapatkan berbagai kunci untuk setiap nilai (misalnya 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)

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

Atau, lebih mudah lagi - buat objek baru dengan kunci dan nilai-nilai dalam urutan yang Anda inginkan kemudian lihatlah terhadap objek itu. Kami mengalami konflik menggunakan kode prototipe di atas. Anda tidak harus menggunakan fungsi String di sekitar tombol, itu opsional.

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

Ini adalah ekstensi kecil untuk metode Underscorejs, dan menggunakan Lodash sebagai gantinya:

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

FindKey akan mencari dan mengembalikan kunci pertama yang cocok dengan nilainya.
Jika Anda menginginkan pertandingan terakhir sebagai gantinya, gunakan FindLastKey sebagai gantinya.

Seolah pertanyaan ini belum dikalahkan hingga bubur ...

Inilah satu hanya untuk rasa ingin tahu apa pun yang membawa Anda ...

Jika Anda yakin bahwa objek Anda hanya akan memiliki nilai string, Anda dapat benar-benar menghabiskan diri untuk menyulap implementasi ini:

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

Mungkin ada sesuatu yang berguna untuk dibangun dari sini ...

Semoga ini menghibur Anda.

Inilah solusi Lodash untuk ini yang berfungsi untuk objek nilai kunci datar =>, daripada objek bersarang. Saran jawaban yang diterima untuk menggunakan _.findKeykarya untuk objek dengan objek bersarang, tetapi itu tidak berfungsi dalam keadaan umum ini.

Pendekatan ini membalikkan objek, menukar kunci untuk nilai, dan kemudian menemukan kunci dengan mencari nilai pada objek baru (terbalik). Jika kunci tidak ditemukan maka falsedikembalikan, yang saya sukai undefined, tetapi Anda dapat dengan mudah menukar ini di parameter ketiga _.getmetode di 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>

Ini solusinya dulu:

Sebagai contoh, saya kira kita memiliki objek yang berisi tiga pasangan nilai:

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

Kita cukup menulis findKey (array, value) yang mengambil dua parameter yang merupakan objek dan nilai kunci yang Anda cari. Dengan demikian, metode ini dapat digunakan kembali dan Anda tidak perlu mengulangi objek secara manual setiap kali dengan hanya melewatkan dua parameter untuk fungsi ini.

Metode ES6 :

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

Saya biasanya merekomendasikan lodash daripada garis bawah.

Jika Anda memilikinya, gunakan itu.

Jika tidak, maka Anda harus mempertimbangkan menggunakan paket lodash.invert npm, yang cukup kecil.

Inilah cara Anda mengujinya menggunakan tegukan:

1) Buat file bernama gulpfile.js dengan konten berikut:

// 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) Instal paket lodash.invert dan teguk

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

3) Uji itu berfungsi:

$ 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

Referensi

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

https://lodash.com/

Perbedaan antara lodash dan garis bawah

https://github.com/gulpjs/gulp

Garis bawahi solusi 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}

ini bekerja untuk saya untuk mendapatkan kunci / nilai objek.

let obj = {
        'key1': 'value1',
        'key2': 'value2',
        'key3': 'value3',
        'key4': 'value4'
    }
    Object.keys(obj).map(function(k){ 
    console.log("key with value: "+k +" = "+obj[k])    
    
    })
    

Sangat mudah.

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"

Tetap sederhana!

Anda tidak perlu memfilter objek melalui metode atau lib canggih, Javascript memiliki fungsi bawaan bernama Object.values .

Contoh:

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

Ini akan mengembalikan data properti objek.

Referensi

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