Làm thế nào để có được một khóa trong một đối tượng JavaScript theo giá trị của nó?

Tôi có một đối tượng JavaScript khá đơn giản, mà tôi sử dụng như một mảng kết hợp. Có một chức năng đơn giản nào cho phép tôi lấy khóa cho một giá trị hay tôi phải lặp lại đối tượng và tìm ra nó bằng tay?

Với thư viện 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, không có đột biến nguyên mẫu hoặc thư viện bên ngoài.

Thí dụ,

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


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

Không có phương pháp tiêu chuẩn có sẵn. Bạn cần lặp lại và bạn có thể tạo một trình trợ giúp đơn giản:

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'

Một lời cảnh báo : Ngay cả khi những điều trên hoạt động, nói chung là một ý tưởng tồi để mở rộng bất kỳ máy chủ hoặc đối tượng bản địa nào .prototype. Tôi đã làm nó ở đây vì nó rất phù hợp với vấn đề này. Dù sao, có lẽ bạn nên sử dụng chức năng này bên ngoài .prototypevà chuyển đối tượng vào đó.

Như đã nói, lặp đi lặp lại là cần thiết. Chẳng hạn, trong trình duyệt hiện đại, bạn có thể có:

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

Nơi valuechứa giá trị bạn đang tìm kiếm. Nói rằng, tôi có thể sẽ sử dụng một vòng lặp.

Mặt khác, bạn có thể sử dụng một đối tượng "hashmap" thích hợp - có một số triển khai trong JS xung quanh - hoặc do chính bạn thực hiện.

CẬP NHẬT 2018

Sáu năm trôi qua, nhưng tôi vẫn nhận được một số phiếu bầu ở đây, vì vậy tôi cảm thấy như một giải pháp hiện đại hơn - cho trình duyệt / môi trường hiện đại - nên được đề cập trong chính câu trả lời và không chỉ trong các bình luận:

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

Tất nhiên nó cũng có thể là một chức năng:

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

Cách thức 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)];
}

Được tạo cho trình biên dịch đóng để trích xuất tên khóa sẽ không xác định sau khi biên dịch

Phiên bản gợi cảm hơn nhưng sử dụng Object.entrieschức năng trong tương lai

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

ES6 + Một Liners

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

Trả về tất cả các khóa có giá trị:

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

Tôi sử dụng chức năng này:

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

Sử dụng:

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

Giải pháp không lặp

Chức năng chính:

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
}

Đối tượng có khóa và giá trị:

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

Kiểm tra:

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

Giữ nguyên mẫu của bạn sạch sẽ.

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

Thí dụ:

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

Nếu bạn đang làm việc với thư viện Underscore hoặc Lodash , bạn có thể sử dụng hàm _.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'

Tôi đã tạo thư viện bimap ( https://github.com/alethes/bimap ) để thực hiện giao diện bản đồ hai chiều JavaScript mạnh mẽ, linh hoạt và hiệu quả. Nó không có phụ thuộc và có thể sử dụng cả ở phía máy chủ (trong Node.js, bạn có thể cài đặt nó npm install bimap) và trong trình duyệt (bằng cách liên kết với lib / bimap.js ).

Các thao tác cơ bản rất đơn giản:

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"

Truy xuất ánh xạ khóa-giá trị cũng nhanh như nhau theo cả hai hướng. Không có các đối tượng / mảng truyền thống tốn kém dưới mui xe nên thời gian truy cập trung bình không đổi bất kể kích thước của dữ liệu.

không thấy như sau:

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)

Vì các giá trị là duy nhất, nên có thể thêm các giá trị dưới dạng một bộ khóa bổ sung. Điều này có thể được thực hiện với các phím tắt sau.

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

Điều này sẽ cho phép truy xuất thông qua khóa hoặc giá trị:

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

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

Điều này không cho rằng không có yếu tố chung giữa các khóa và giá trị.

Đưa ra input={"a":"x", "b":"y", "c":"x"}...

• Để sử dụng giá trị đầu tiên (ví dụ 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)

• Để sử dụng giá trị cuối cùng (ví dụ 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)

• Để có được một mảng các khóa cho mỗi giá trị (ví dụ 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;
    } 

Hoặc, dễ dàng hơn - tạo một đối tượng mới với các khóa và giá trị theo thứ tự bạn muốn sau đó tìm kiếm đối tượng đó. Chúng tôi đã có xung đột khi sử dụng mã nguyên mẫu ở trên. Bạn không phải sử dụng hàm String xung quanh phím, đó là tùy chọn.

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

Đây là một phần mở rộng nhỏ cho phương thức Underscorejs và sử dụng Lodash thay thế:

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

FindKey sẽ tìm kiếm và trả về khóa đầu tiên khớp với giá trị.
Nếu bạn muốn trận đấu cuối cùng thay vào đó, hãy sử dụng FindLastKey thay thế.

Như thể câu hỏi này chưa bị đánh vào tủy ...

Đây là một thứ chỉ vì bất kỳ sự tò mò nào mà nó mang lại cho bạn ...

Nếu bạn chắc chắn rằng đối tượng của bạn sẽ chỉ có các giá trị chuỗi, bạn thực sự có thể tự làm mình kiệt sức để thực hiện việc triển khai này:

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

Có lẽ có thứ gì đó hữu ích để xây dựng ở đây ...

Hy vọng điều này làm bạn vui.

Đây là một giải pháp Lodash cho giải pháp này hoạt động cho đối tượng khóa phẳng => giá trị, thay vì đối tượng lồng nhau. Đề xuất câu trả lời được chấp nhận để sử dụng _.findKeycác tác phẩm cho các đối tượng với các đối tượng lồng nhau, nhưng nó không hoạt động trong trường hợp phổ biến này.

Cách tiếp cận này đảo ngược đối tượng, hoán đổi các khóa cho các giá trị và sau đó tìm khóa bằng cách tra cứu giá trị trên đối tượng mới (đảo ngược). Nếu khóa không tìm thấy thì falseđược trả về, cái mà tôi thích hơn undefined, nhưng bạn có thể dễ dàng trao đổi cái này trong tham số thứ ba của _.getphương thức trong 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>

Đây là giải pháp của tôi đầu tiên:

Ví dụ: tôi cho rằng chúng ta có một đối tượng chứa ba cặp giá trị:

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

Chúng ta có thể chỉ cần viết một findKey (mảng, giá trị) có hai tham số là một đối tượng và giá trị của khóa mà bạn đang tìm kiếm. Như vậy, phương thức này có thể tái sử dụng và bạn không cần phải lặp lại thủ công đối tượng mỗi lần bằng cách chỉ truyền hai tham số cho hàm này.

Phương pháp ES6 :

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

Tôi thường khuyên bạn nên lodash hơn là gạch dưới.

Nếu bạn có nó, sử dụng nó.

Nếu bạn không, thì bạn nên cân nhắc sử dụng gói npm lodash.invert, khá nhỏ.

Đây là cách bạn có thể kiểm tra nó bằng cách sử dụng gulp:

1) Tạo một tệp có tên gulpfile.js với các nội dung sau:

// 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) Cài đặt gói lodash.invert và gulp

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

3) Kiểm tra xem nó hoạt động:

$ 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

Người giới thiệu

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

https://lodash.com/

Sự khác nhau giữa lodash và gạch dưới

https://github.com/gulpjs/gulp

Giải pháp gạch dưới

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}

điều này làm việc cho tôi để có được khóa / giá trị của đối tượng.

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

Thực sự đơn giản.

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"

Giữ cho nó đơn giản!

Bạn không cần phải lọc đối tượng thông qua các phương thức hoặc libs tinh vi, Javascript có chức năng tích hợp có tên Object.values .

Thí dụ:

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

Điều này sẽ trả về dữ liệu thuộc tính đối tượng.

Người giới thiệu

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