अपने मूल्य से जावास्क्रिप्ट ऑब्जेक्ट में एक कुंजी कैसे प्राप्त करें?

Question

मेरे पास एक बहुत ही सरल जावास्क्रिप्ट ऑब्जेक्ट है, जिसे मैं एक सहयोगी सरणी के रूप में उपयोग करता हूं। क्या एक साधारण कार्य है जो मुझे मूल्य के लिए कुंजी प्राप्त करने की अनुमति देता है, या क्या मुझे ऑब्जेक्ट को पुनरावृत्त करना है और इसे मैन्युअल रूप से पता लगाना है?

Comments

ऐसा करने के लिए ऐसा कोई मानक कार्य नहीं है। यदि मैपिंग वास्तव में द्विदिश है तो "फ़्लिप" मैप और इंडेक्स का निर्माण करना तुच्छ है। अन्यथा एक साधारण प्रॉपर्टी-इटरेटर (एक hasOwnProperty gaurd के साथ, शायद) और एक फ़ंक्शन के अंदर छिपा हुआ एक प्रारंभिक रिटर्न बस अच्छी तरह से करता है ...

यदि किसी वस्तु को एक से अधिक कुंजी द्वारा संदर्भित किया जाता है तो यह कैसे काम कर सकता है? var o = []; var map = {first: o, second: o}। क्या find_key(o)लौटेगा?

— गारेथ

कोई फर्क नहीं पड़ता;) मैं केवल अद्वितीय कुंजी-मूल्य-जोड़े के साथ एक सरणी के लिए इसका उपयोग करने का इरादा रखता हूं।

— एरिक

एक कुंजी / मान जावास्क्रिप्ट वस्तु की कुंजी पाने के लिए सबसे अच्छे तरीके से

— एंडी

मैंने इसका एक संस्करण बनाया है बिना iteration stackoverflow.com/a/36705765/696535 । यह दिलचस्प होगा कि jsfiddle में सभी प्रस्तावित समाधानों का परीक्षण करें

— पावेल

Answer 1

साथ Underscore.js पुस्तकालय:

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

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

Comments

@GeorgeJempty हर कोई एक साधारण कुंजी लुकअप के लिए 5kb लाइब्रेरी लोड नहीं करना चाहता;)

— tckmn

किसी भी समाधान की तलाश करने वाले किसी भी व्यक्ति के लिए बस FYI करें, आपको मूल्य से मेल खाने वाली सभी कुंजियाँ मिलेंगी: यह काम नहीं करेगा।

— ब्रेट

अंडरस्कोर कीज़ भी काम करेगी। underscorejs.org/#keys _.keys ({एक: 1, दो: 2, तीन: 3}); => ["एक", "दो", "तीन"]

— थादेसस अल्बर्स

_.invert काम नहीं करता है जहां मानों में ऑब्जेक्ट शामिल होते हैं जैसे कि डिफ़ॉल्ट स्ट्रिंग क्रमांकन टकराता है। आप इस घृणित प्रयोग कर सकते हैं:_.chain(hash).pairs().findWhere({1: 1}).value()[0]

— DanHorner

यह स्वीकृत उत्तर नहीं होना चाहिए, यह एक पुस्तकालय के माध्यम से एक समाधान का प्रस्ताव करता है जो वर्तमान कोड संरचना में बदलाव के लिए मजबूर करता है

— Matteo

Answer 2

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

ES6, कोई प्रोटोटाइप म्यूटेशन या बाहरी लाइब्रेरी नहीं है।

उदाहरण,

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


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

Comments

यदि आप IE11 का समर्थन नहीं करते हैं तो ठीक है, वास्तव में साफ करें। यदि हां, तो आपको एक

— पॉलीफिल की

कार्यान्वयन के आधार पर, यह संभवतः O (n) स्थान लेता है क्योंकि keys()कुंजी सेट को भौतिक करता है।

— डेविड एहरमन

साफ लेकिन धीमा।

— चलाये जाने योग्य

अगर मल्टीपल कीज़ में सेम वैल्यू function getKeyByValue(object, value) { return Object.keys(object).filter(key => object[key] === value); }

— यूज़

जबरदस्त हंसी। यह धीमा नहीं है, यह O (n) है जो बहुत अधिक संभव रनटाइम है।

— बेन वेनराइट

Answer 3

कोई मानक विधि उपलब्ध नहीं है। आपको पुनरावृति करने की आवश्यकता है और आप एक साधारण सहायक बना सकते हैं:

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'

सावधानी का एक शब्द : भले ही ऊपर काम करता है, आम तौर पर किसी भी मेजबान या देशी वस्तु का विस्तार करने के लिए एक बुरा विचार है .prototype। मैंने इसे यहां किया क्योंकि यह मुद्दे को अच्छी तरह से फिट करता है। वैसे भी, आपको संभवतः इस फ़ंक्शन का उपयोग बाहर करना चाहिए .prototypeऔर इसके स्थान पर ऑब्जेक्ट पास करना चाहिए।

Comments

वास्तव में यह ठीक है अगर आप इस तरह की चीजों को जानते हैं कि फॉर-लूप संपत्ति श्रृंखला में नीचे चला जाता है, जिसका अर्थ है "ओब्जेक्ट में var कुंजी" के लिए आपको "getKeyByValue" कुछ बिंदु पर "कुंजी" के रूप में मिलेगा।

अरे यार मैं प्यार करता हूँ कि अगर मूल्य मौजूद नहीं है तो यह चुपके से अपरिभाषित कैसे लौटता है। बहुत बढ़िया। इसके अलावा, बस रुचि का एक बिंदु, यह O (n) प्रदर्शन करेगा यदि ऑब्जेक्ट में एक टन संपत्ति (जैसे एक बड़े शहर में लोगों की सूची और उनके पते) हैं, तो आप शायद अधिक कुशल खोज चाहते हैं। शायद मूल्यों और बाइनरी खोज को सॉर्ट करें? एह?

— कोर्बिन नोव

बहुत बहुत धन्यवाद, जब तक मैंने बुरा विचार देखा, मुझे आश्चर्य है कि फिर मैंने इस के माध्यम से क्यों खोजा और इस उत्तर वृद्धि और व्यापक पढ़ने के लिए यहां जोड़ा। stackoverflow.com/questions/3085240/…

— simongcc

@jAndy यह === नहीं है, यह == है। आपका कोड === के साथ काम नहीं करता है। यह अपरिभाषित लौटता है।

— डेक्सटर

मैं इसे एक स्ट्रिंग में कनवर्ट कर लगता है कि ठीक प्रकार त्रुटियों के लिए बेहतर होगा सिर्फ जोड़ने .toString()की तरह obj[ key ].toString()और मूल्य के लिए अगर वांछित ...

— CrandellWS

Answer 4

जैसा कि कहा गया है, पुनरावृत्ति की आवश्यकता है। उदाहरण के लिए, आधुनिक ब्राउज़र में आप हो सकते हैं:

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

कहाँ valueमूल्य आप देख रहे हैं शामिल हैं। कहा कि, मैं शायद एक लूप का उपयोग करूंगा।

अन्यथा आप एक उचित "हैशमैप" ऑब्जेक्ट का उपयोग कर सकते हैं - जेएस में कई कार्यान्वयन हैं - या अपने स्वयं के द्वारा लागू।

UPDATE 2018

छह साल बीत गए, लेकिन मुझे अभी भी यहाँ कुछ वोट मिलते हैं, इसलिए मुझे लगता है कि आधुनिक ब्राउज़र / पर्यावरण के लिए एक और अधिक आधुनिक समाधान की तरह है - इसका उत्तर स्वयं में दिया जाना चाहिए, न कि केवल टिप्पणियों में:

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

बेशक यह भी एक समारोह हो सकता है:

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

Comments

ईएस 6:Object.keys(obj).or(o=>o[key] === value)

— बेंजामिन ग्रुएनबाउम

दुर्भाग्य से तीर फ़ंक्शन अभी तक कोई भी "आधुनिक" ब्राउज़र नहीं है, इसलिए यह इस समय थोड़ा बेकार है - मैं फ़ायरफ़ॉक्स नाइटली पर जेटपैक में इसका उपयोग कर रहा हूं, यह फ़ायरफ़ॉक्स 22 में होगा। वैसे भी, मैं किसी भी orसरणी के बारे में नहीं जानता हूं विधि, और यह यहाँ मेरे उद्देश्य के लिए स्पष्ट नहीं है: मैं कुछ अतिरिक्त विस्तार की सराहना करूंगा! :)

— ZER0

तीर के रूप में, यह आ रहा है और मैं इसके लिए इंतजार कर रहा हूँ :) जैसा orकि सुनिश्चित है! यह केवल हाल ही में मूल्यांकन किया गया और स्वीकार किया गया (मुझे नहीं लगता कि किसी ने इसे अभी तक लागू नहीं किया है)। यह क्या करता है एक सरणी का पहला तत्व एक विधेय से मेल खाता है और इसे वापस कर दें। इसलिए [1,2,3,4].or(x=>x>2)लौट जाता 3और [1,2,3,4,5].or(x=>x<3)लौट जाता 1। कुछ ऐसा है जैसे C # का FirstOrDefault :)

— बेंजामिन Gruenbaum

हाँ, तीर आ रहा है, लेकिन इसे व्यापक रूप से उपयोग में लिया जाएगा - जब तक मैं नहीं करता, किसी के विशिष्ट इंजन पर काम करना। मुझे ES6 के नए प्रस्ताव के बारे में पता नहीं था, मुझे लगा कि यह बहुत ही बंद है: क्या आपके पास orविधि के बारे में कोई लिंक है ? आपने जो उल्लेख किया है उससे ऐसा लगता है कि यह उस वस्तु को लौटाता है जो विधेय से मेल खाती है "या" सरणी ही?

— ZER0

@ sg552 जैसा कि बाद में उल्लेख किया गया orथा , का नाम बदल दिया गया था। मेरा मानना ​​है कि अब आपको खोज का उपयोग करना चाहिए ।

— ZER0

Answer 5

लॉश रास्ता 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'

Comments

लोदश स्पष्ट रूप से इस मुद्दे का सबसे अच्छा समाधान है। इससे भी बेहतर, मुझे लगता है, अंडरस्कोर तरीके से।

— एरिक

FYI करें, "अंडरस्कोर तरीका": _.findKey(users, { 'age': 1, 'active': true });... यह वही है

— craigmichaelmartin

यदि सरणी वह मान है जिसका आपको उपयोग करने की आवश्यकता है: - obj = {a: [1, 2], b: [3, 4], c: [5, 6]} _.findKey (obj, function (val) { वापसी _.इस्क्वाल (घाटी, [5, 6]);});

— आशीषदैवी 11

यदि आपके मूल्य सरल हैं, जैसे तार या पूर्णांक, तो अपेक्षा के विपरीत यह काम नहीं करेगा। जैसे _.find_key({a: "A", b:"B"}, "B"})रिटर्न undefinedइतनी के रूप में कहा गया है यहाँ आपको बस इतना करना _.find_key({a: "A", b:"B"}, _.partial(_.isEqual,"B")})

— ryan2johnson9

@ ryan2johnson9 यह लॉडश के साथ मेरी समस्या है। मुझे कुछ कार्यों को समझने में मुश्किल समय आ रहा है (जाहिर है कि मैं केवल एक ही हूं)। लेकिन वैसे भी धन्यवाद, यह काम करता है। मुझे दूसरा, छोटा समाधान मिला। यह बड़ी वस्तुओं पर अधिकता का कारण बनता है इसलिए इस एक के साथ सावधान रहें। _.invert(haystack)[needle]

— Empi

Answer 6

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

मुख्य नाम निकालने के लिए क्लोजर कंपाइलर के लिए बनाया गया है जो संकलन के बाद अज्ञात होगा

अधिक सेक्सी संस्करण लेकिन भविष्य के Object.entriesफ़ंक्शन का उपयोग करना

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

Comments

मुझे लगता है कि यह 2017 के लिए सबसे अच्छा एक है क्योंकि यह सादे जावास्क्रिप्ट का उपयोग करता है।

— ब्रेनबैग

यदि आपके पास दो या दो से अधिक संख्याएँ हैं, तो उनका मूल्य समान नहीं है

— JuicY_Burrito

@SamuelChen यह सही है लेकिन अगर यह काम करता है तो इसका मतलब होगा कि परिणाम के रूप में एक सरणी की आवश्यकता है। इसके बजाय कहां Object.entries(obj).find(i => i[1] === val);उपयोग करेंfilterObject.entries(obj).filter(i => i[1] === val);

— पावेल

Answer 7

ES6 + एक लाइनर

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

---

मान के साथ सभी कुंजियाँ लौटाएँ:

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

Comments

कोई भी निर्भरता होने पर स्वीकृत उत्तर होना चाहिए।

— एंड्रयू शुल्त्स

Answer 8

मैं इस फ़ंक्शन का उपयोग करता हूं:

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

उपयोग:

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

Comments

+1 साफ समाधान। लेकिन मेरा एक सवाल है: क्या आपको obj.hasOwnProperty(key)इस मामले में हमेशा जाँच नहीं करनी चाहिए या यह अनावश्यक है?

— वी-लाइट

ऑब्जेक्ट प्रोटोटाइप को

— म्यूट

Answer 9

गैर-पुनरावृत्त समाधान

मुख्य कार्य:

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
}

चाबियाँ और मूल्यों के साथ वस्तु:

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

परीक्षा:

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

Comments

सरल: Object.keys(greetings )[Object.values(greetings ).indexOf('привіт')]

— shutsman

Answer 10

अपने प्रोटोटाइप को साफ रखें ।

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

उदाहरण:

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

Answer 11

यदि आप अंडरस्कोर या लॉडश लाइब्रेरी के साथ काम कर रहे हैं , तो आप _.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'

Answer 12

मैंने bimap लाइब्रेरी ( https://github.com/alethes/bimap ) बनाई जो एक शक्तिशाली, लचीले और कुशल जावास्क्रिप्ट बिडायरेक्शनल मैप इंटरफ़ेस को लागू करती है। इसकी कोई निर्भरता नहीं है और सर्वर-साइड (Node.js में, आप इसे इसके साथ इंस्टॉल कर सकते हैं npm install bimap) और ब्राउज़र में ( lib / bimap.js से लिंक करके ) उपयोग करने योग्य हैं।

मूल संचालन वास्तव में सरल हैं:

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"

कुंजी-मूल्य मैपिंग की पुनर्प्राप्ति दोनों दिशाओं में समान रूप से तेज़ है। हुड के तहत कोई महंगा वस्तु / सरणी ट्रैवर्सल्स नहीं हैं, इसलिए डेटा के आकार की परवाह किए बिना औसत पहुंच समय स्थिर रहता है।

Comments

एकमात्र समाधान में से एक जिसे पुनरावृत्ति की आवश्यकता नहीं है (या तो समाधान में ही, मानक पुस्तकालय या अन्य पुस्तकालय)।

— स्कॉट रुडिगर

Answer 13

निम्नलिखित नहीं देखा:

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 14

चूंकि मान अद्वितीय हैं, इसलिए कुंजियों के अतिरिक्त सेट के रूप में मूल्यों को जोड़ना संभव होना चाहिए। यह निम्नलिखित शॉर्टकट के साथ किया जा सकता है।

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

यह कुंजी या मूल्य के माध्यम से पुनर्प्राप्ति की अनुमति देगा:

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

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

यह मान लेता है कि कुंजियों और मूल्यों के बीच कोई सामान्य तत्व नहीं हैं।

Comments

सभी समाधानों को ब्राउज़ करते हुए, मैं इस एक के साथ चला गया। बहुत सहज है।

— nehem

एकमात्र समाधान में से एक जिसे पुनरावृत्ति की आवश्यकता नहीं है (या तो समाधान में ही, मानक पुस्तकालय या अन्य पुस्तकालय)।

— स्कॉट रुडिगर

ओपी ने कहा कि कुंजी / मूल्य जोड़े सभी अद्वितीय थे इसलिए यह कम-तकनीकी जवाब शानदार है! शाबाश;)

— कस्टमकॉमैंडर

Answer 15

दिया input={"a":"x", "b":"y", "c":"x"}...

• पहले मान का उपयोग करने के लिए (उदाहरण के लिए 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)

• अंतिम मान (उदाहरण के लिए 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)

• प्रत्येक मान के लिए कुंजियों का एक सरणी प्राप्त करने के लिए (जैसे 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)

Comments

यह निश्चित रूप से सबसे अच्छा जवाब है, लेकिन मैं अपने सिर को एक तरीके से बदलने के लिए इसे खरोंच रहा था ताकि किसी दिए गए ऑब्जेक्ट के लिए केवल कुंजी लौटाया जा सके, अर्थात् किसी सरणी के लिए अनुक्रमणिका के बराबर कार्य किया जाए।

— सौहैब बेसब्स

जब तक मेमोरी एक बाधा नहीं होती है और आप कई बार ओवर ऑब्जेक्ट के माध्यम से देखने के लिए बहुत सारी प्रोसेसिंग पावर खर्च करने को तैयार रहते हैं, बस "आउटपुट" को एक वैरिएबल के ऊपर बताए अनुसार सेव करें और परिणाम को वहीं देखें ... जैसे output['x']। क्या आप जो पूछ रहे थे?

— फाबियो बेल्ट्रामिनी

Answer 16

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

Comments

@ Fr0zenFyr: निम्नलिखित लिंक आपको बेहतर प्रश्न का उत्तर दे सकता है - stackoverflow.com/questions/8423493/…

— Atur

Answer 17

या, अभी तक आसान - आप चाहते हैं तो उस वस्तु के खिलाफ देखने के क्रम में कुंजी और मूल्यों के साथ एक नई वस्तु बनाएं। हमने ऊपर दिए गए प्रोटोटाइप कोड का उपयोग करके विरोध किया है। आपको कुंजी के चारों ओर स्ट्रिंग फ़ंक्शन का उपयोग करने की आवश्यकता नहीं है, जो वैकल्पिक है।

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

Answer 18

यह अंडरस्कोरज विधि के लिए एक छोटा सा विस्तार है, और इसके बजाय लोडश का उपयोग करता है :

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

FindKey पहली कुंजी को खोजेगा और लौटाएगा जो मूल्य से मेल खाता है।
यदि आप इसके बजाय अंतिम मैच चाहते हैं, तो इसके बजाय FindLastKey का उपयोग करें।

Answer 19

मानो इस सवाल को किसी गूदे ने नहीं पीटा है ...

यहाँ एक जो कुछ भी जिज्ञासा के लिए यह आप लाता है ...

यदि आप सुनिश्चित हैं कि आपकी वस्तु में केवल स्ट्रिंग मान होंगे, तो आप वास्तव में इस कार्यान्वयन को पूरा करने के लिए अपने आप को समाप्त कर सकते हैं:

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

शायद यहाँ से कुछ उपयोगी बनाने के लिए है ...

आशा है कि यह आपको खुश करता है

Answer 20

यहाँ एक Lodash समाधान है जो समतल कुंजी => मान ऑब्जेक्ट के लिए काम करता है, बजाय एक नीडिंत वस्तु के। उपयोग करने के लिए स्वीकृत उत्तर का सुझाव_.findKeyनेस्टेड ऑब्जेक्ट्स के साथ काम , लेकिन यह इस सामान्य परिस्थिति में काम नहीं करता है।

यह दृष्टिकोण ऑब्जेक्ट को बदलता है, मानों के लिए कुंजियों की अदला-बदली करता है, और फिर नए (इनवर्ट) ऑब्जेक्ट पर मूल्य को देखकर कुंजी पाता है। यदि कुंजी नहीं मिली है, तो falseउसे वापस कर दिया जाता है, जिसे मैं पसंद करता हूं undefined, लेकिन आप इसे आसानी से _.getविधि के तीसरे पैरामीटर में स्वैप कर सकते हैं 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 21

यहाँ मेरा समाधान पहले है:

उदाहरण के लिए, मुझे लगता है कि हमारे पास एक ऐसी वस्तु है जिसमें तीन मूल्य जोड़े हैं:

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

हम बस एक findKey (array, value) लिख सकते हैं जो दो मापदंडों को लेता है जो एक ऑब्जेक्ट हैं और उस कुंजी का मूल्य जिसे आप ढूंढ रहे हैं। जैसे, यह विधि पुन: प्रयोज्य है और आपको इस फ़ंक्शन के लिए केवल दो मापदंडों को पारित करके हर बार ऑब्जेक्ट को मैन्युअल रूप से पुन: व्यवस्थित करने की आवश्यकता नहीं है।

Answer 22

ES6 विधियाँ:

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

Answer 23

मैं आमतौर पर अंडरस्कोर के बजाय लॉश की सलाह देता हूं।

यदि आपके पास यह है, तो इसका उपयोग करें।

यदि आप नहीं करते हैं, तो आपको lodash.invert npm पैकेज का उपयोग करने पर विचार करना चाहिए, जो कि बहुत छोटा है।

यहाँ आप इसे gulp का उपयोग करके कैसे देख सकते हैं:

1) निम्नलिखित सामग्री के साथ gulpfile.js नामक एक फ़ाइल बनाएँ:

// 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 पैकेज और gulp स्थापित करें

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

3) परीक्षण करें कि यह काम करता है:

$ 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

संदर्भ

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

https://lodash.com/

लॉश और अंडरस्कोर के बीच अंतर

https://github.com/gulpjs/gulp

Comments

यहाँ गुल क्यों शामिल है? बस स्क्रिप्ट चलाने ...

— Ry-

Answer 24

अंडरस्कोर जेएस समाधान

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 25

इसने मेरे लिए वस्तु का मुख्य / मूल्य प्राप्त करने के लिए काम किया।

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 26

वास्तव में सीधा है।

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"

Comments

इस बात की कोई गारंटी नहीं है कि ऑब्जेक्ट ऑर्डर समान होगा ...

— डाउनगोट

Answer 27

इसे सरल रखें!

आपको परिष्कृत तरीकों या कामों के माध्यम से ऑब्जेक्ट को फ़िल्टर करने की आवश्यकता नहीं है, जावास्क्रिप्ट में एक अंतर्निहित फ़ंक्शन है जिसे ऑब्जेक्ट.वेल्यूज़ कहा जाता है ।

उदाहरण:

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

यह ऑब्जेक्ट प्रॉपर्टी डेटा लौटाएगा।

संदर्भ

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