Bir JavaScript nesnesindeki değerine göre bir anahtar nasıl alınır?

İlişkilendirilebilir dizi olarak kullandığım oldukça basit bir JavaScript nesnesim var. Bir değerin anahtarını almama izin veren basit bir işlev var mı, yoksa nesneyi yinelemeli ve manuel olarak öğrenmem gerekiyor mu?

İle Underscore.js kütüphanesinde:

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

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

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

ES6, prototip mutasyonları veya harici kütüphaneler yok.

Misal,

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


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

Standart bir yöntem yoktur. Yinelemeniz gerekiyor ve basit bir yardımcı oluşturabilirsiniz:

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'

Dikkat edilmesi gereken bir kelime : Yukarıdakiler işe yararsa bile, genellikle herhangi bir ana bilgisayarı veya yerel nesneyi genişletmek kötü bir fikirdir .prototype. Burada yaptım çünkü konuya çok iyi uyuyor. Her neyse, muhtemelen bu işlevi dışında kullanmalı .prototypeve onun yerine nesneyi geçirmelisiniz.

Söylendiği gibi, yineleme gereklidir. Örneğin, modern tarayıcıda şunlar olabilir:

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

valueAradığınız değeri burada içerir. Büyük olasılıkla bir döngü kullanacağımı söyledi.

Aksi takdirde, uygun bir "hashmap" nesnesi kullanabilirsiniz - JS'de birkaç uygulama vardır - veya kendi başına uygulayabilirsiniz.

GÜNCELLEME 2018

Altı yıl geçti, ama yine de burada biraz oy alıyorum, bu yüzden daha modern bir çözüm gibi hissediyorum - modern tarayıcı / çevre için - sadece yorumlarda değil cevapta belirtilmelidir:

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

Tabii ki aynı zamanda bir fonksiyon olabilir:

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

Lodash yolu 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)];
}

Derleme sonrası bilinmeyecek anahtar adını ayıklamak için kapatma derleyicisinin üretilmesi

Daha seksi versiyonu ama gelecek Object.entriesfonksiyonunu kullanarak

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

ES6 + Bir Astar

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

Değerli tüm anahtarları döndür:

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

Bu işlevi kullanıyorum:

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

Kullanımı:

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

Tekrarlanamayan çözüm

Ana işlev:

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
}

Anahtarları ve değerleri olan nesne:

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

Ölçek:

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

Prototipinizi temiz tutun .

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

Misal:

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

Underscore veya Lodash kütüphanesi ile çalışıyorsanız , _.findKey işlevini kullanabilirsiniz :

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'

Oluşturduğum bimap kitaplığı ( https://github.com/alethes/bimap güçlü, esnek ve verimli bir JavaScript çift yönlü harita arayüzü uygulayan). Bağımlılığı yoktur ve hem sunucu tarafında (Node.js'de, yükleyebilirsiniz npm install bimap) hem de tarayıcıda ( lib / bimap.js'ye bağlayarak) kullanılabilir ) kullanılabilir.

Temel işlemler gerçekten basit:

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"

Anahtar / değer eşlemesinin alınması her iki yönde de eşit derecede hızlıdır. Kaputun altında pahalı bir nesne / dizi geçişi yoktur, bu nedenle ortalama erişim süresi verilerin boyutundan bağımsız olarak sabit kalır.

aşağıdakileri görmedim:

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)

Değerler benzersiz olduğundan, değerleri ek bir anahtar kümesi olarak eklemek mümkün olmalıdır. Bu, aşağıdaki kısayol ile yapılabilir.

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

Bu, anahtar veya değer yoluyla alınmasına izin verir:

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

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

Bu, anahtarlar ve değerler arasında ortak bir öğe olmadığını varsayar.

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

• İlk değeri kullanmak için (ör. 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)

• Son değeri kullanmak için (örn. 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)

• Her bir değer için bir dizi anahtar almak için (ör. 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;
    } 

Ya da, daha kolay - anahtarlar ve değerlerle istediğiniz sırada yeni bir nesne oluşturun ve o nesneye bakın. Yukarıdaki prototip kodlarını kullanırken çakışmalar yaşadık. Anahtarın etrafında String işlevini kullanmak zorunda değilsiniz, bu isteğe bağlıdır.

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

Bu Underscorejs yönteminin küçük bir uzantısıdır ve bunun yerine Lodash kullanır:

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

FindKey olacaktır arama ve ilk anahtarı geri değeriyle eşleşir.
Bunun yerine son eşleşmeyi istiyorsanız, bunun yerine FindLastKey kullanın.

Bu soru bir hamur haline gelmemiş gibi ...

İşte size getirdiği meraktan bir tanesi ...

Nesnenizin yalnızca dize değerlerine sahip olacağından eminseniz, bu uygulamayı oluşturmak için kendinizi gerçekten tüketebilirsiniz:

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

Belki buradan inşa etmek için faydalı bir şey var ...

Umarım bu sizi eğlendirir.

İşte bunun için iç içe bir nesne yerine düz anahtar => değer nesnesi için çalışan bir Lodash çözümü. Kabul edilen yanıtın kullanma önerisi_.findKey , iç içe nesneler içeren nesneler için çalışır, ancak bu genel durumda çalışmaz.

Bu yaklaşım, değerleri ters çevirerek nesneyi tersine çevirir ve sonra yeni (ters çevrilmiş) nesne üzerindeki değeri arayarak anahtarı bulur. Eğer anahtar bulunmazsa false, geri dönersem, hangisini tercih ederim undefined, ama bunu _.getyöntemin üçüncü parametresinde kolayca değiştirebilirsiniz 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>

İşte benim ilk çözüm:

Örneğin, üç değer çifti içeren bir nesnemiz olduğunu varsayalım:

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

Sadece bir nesne ve aradığınız anahtarın değeri olan iki parametre alan bir findKey (dizi, değer) yazabiliriz. Bu nedenle, bu yöntem yeniden kullanılabilir ve bu işlev için yalnızca iki parametre geçirerek nesneyi her seferinde manuel olarak yinelemenize gerek yoktur.

ES6 yöntemleri:

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

Genellikle alt çizgi yerine lodash öneririm.

Elinizde varsa kullanın.

Bunu yapmazsanız, oldukça küçük olan lodash.invert npm paketini kullanmayı düşünmelisiniz.

Yutmayı kullanarak nasıl test edebileceğiniz aşağıda açıklanmıştır:

1) Aşağıdaki içeriğe sahip gulpfile.js adlı bir dosya oluşturun:

// 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) Lodash.invert paketini ve yutmayı takın

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

3) Çalışıp çalışmadığını test edin:

$ 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

Referanslar

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

https://lodash.com/

Lodash ve alt çizgi arasındaki farklar

https://github.com/gulpjs/gulp

Alt çizgi js çözümü

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}

bu benim için nesnenin anahtarını / değerini elde etmemde işe yaradı.

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

Gerçekten anlaşılır.

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"

Basit tutun!

Nesneyi gelişmiş yöntemlerle veya kütüphanelerle filtrelemenize gerek yoktur, Javascript'te Object.values adlı yerleşik bir işlev vardır .

Misal:

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

Bu, nesne özelliği verilerini döndürür.

Referanslar

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