javascript - एक जावास्क्रिप्ट ऑब्जेक्ट में कोई कुंजी मौजूद है या नहीं?




arrays object (13)

ईएस 6 समाधान

Array#some और Object.keys का उपयोग कर। यदि ऑब्जेक्ट में दी गई कुंजी मौजूद है या गलत नहीं है तो यह सच हो जाएगा।

var obj = {foo: 'one', bar: 'two'};
    
function isKeyInObject(obj, key) {
    var res = Object.keys(obj).some(v => v == key);
    console.log(res);
}

isKeyInObject(obj, 'foo');
isKeyInObject(obj, 'something');

एक पंक्ति उदाहरण।

console.log(Object.keys({foo: 'one', bar: 'two'}).some(v => v == 'foo'));

जावास्क्रिप्ट ऑब्जेक्ट या सरणी में कोई विशेष कुंजी मौजूद है या नहीं?

यदि कोई कुंजी मौजूद नहीं है, और मैं इसे एक्सेस करने का प्रयास करता हूं, तो क्या यह झूठी वापसी करेगा? या एक त्रुटि फेंक दो?


यहां एक सहायक कार्य है जो मुझे काफी उपयोगी लगता है

यह keyExists(key, search) वस्तुओं या सरणी के भीतर आसानी से एक कुंजी देखने के लिए इस्तेमाल किया जा सकता है!

बस इसे वह कुंजी पास करें जिसे आप ढूंढना चाहते हैं, और ओबीजे (ऑब्जेक्ट या सरणी) को खोजें जिसे आप इसे ढूंढना चाहते हैं।

function keyExists(key, search) {
    if (!search || (search.constructor !== Array && search.constructor !== Object)) {
        return false;
    }
    for (var i = 0; i < search.length; i++) {
        if (search[i] === key) {
            return true;
        }
    }
    return key in search;
}

इसे कैसे उपयोग करे:

Arrays में कुंजी के लिए खोज रहे हैं

keyExists('apple', ['apple', 'banana', 'orange']); // true
keyExists('fruit', ['apple', 'banana', 'orange']); // false

वस्तुओं में कुंजी के लिए खोज रहे हैं

keyExists('age', {'name': 'Bill', 'age': 29 }); // true
keyExists('title', {'name': 'Jason', 'age': 29 }); // false

यह बहुत विश्वसनीय रहा है और अच्छी तरह से क्रॉस ब्राउज़र काम करता है।


उनके प्रोजेक्ट में lodash करने वाले लोगों के लिए:
एक lodash _.get विधि है जो "गहरी" कुंजी प्राप्त करने का प्रयास करती है:

वस्तु के पथ पर मूल्य प्राप्त करता है। यदि हल किया गया मान अपरिभाषित है, तो डिफ़ॉल्ट स्थान को इसके स्थान पर वापस कर दिया जाता है।

var object = { 'a': [{ 'b': { 'c': 3 } }] };

console.log(
  _.get(object, 'a[0].b.c'),           // => 3
  _.get(object, ['a', '0', 'b', 'c']), // => 3
  _.get(object, 'a.b.c'),              // => undefined 
  _.get(object, 'a.b.c', 'default')    // => 'default'
)
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js"></script>

यह प्रभावी ढंग से जांच करेगा कि क्या कुंजी, हालांकि गहरी , परिभाषित की गई है और एक त्रुटि नहीं फेंक देगी जो आपके प्रोग्राम के प्रवाह को नुकसान पहुंचा सकती है यदि वह कुंजी परिभाषित नहीं है।


हम उपयोग कर सकते हैं - hasOwnProperty.call(obj, key);

underscore.js रास्ता -

if(_.has(this.options, 'login')){
  //key 'login' exists in this.options 
}

_.has = function(obj, key) {
  return hasOwnProperty.call(obj, key);
};

जांच करने का सबसे आसान तरीका है

let obj = {
    "key1": "value1",
    "key2": "value2",
    "key3": "value3",
};

let {key1, key2, key3, key4} = obj;

// key1 = "value1"
// key2 = "value2"
// key3 = "value3"
// key4 = undefined

// Can easily use `if` here on key4
if(!key4) { console.log("key not present"); } // Key not present

उदाहरण के लिए:

var keyExistsOn = (o, k) => k.split(".").reduce((a, c) => a.hasOwnProperty(c) ? a[c] || 1 : false, Object.assign({}, o)) === false ? false : true;

सत्य के रूप में वापसी मूल्य का तात्पर्य है कि वस्तु में कुंजी मौजूद है।


जावास्क्रिप्ट ऑब्जेक्ट में कोई संपत्ति मौजूद है या नहीं, यह जांचने के तीन तरीके:

  1. !! obj.theProperty
    मूल्य को बूल में परिवर्तित कर देगा। सभी के लिए 'झूठी' मान के लिए सत्य लौटाता है
  2. obj में 'प्रॉपर्टी'
    यदि संपत्ति मौजूद है तो सत्य वापस आ जाएगा, इससे कोई फर्क नहीं पड़ता कि उसका मूल्य (यहां तक ​​कि खाली)
  3. obj.hasOwnProperty ( 'theProperty')
    प्रोटोटाइप श्रृंखला की जांच नहीं करता है। (चूंकि सभी ऑब्जेक्ट्स में 'toString' विधि होती है, 1 और 2 उस पर सच हो जाएंगी, जबकि 3 उस पर झूठी वापसी कर सकती है।)

संदर्भ:

http://book.mixu.net/node/ch5.html


यदि आप किसी ऑब्जेक्ट पर किसी भी गहराई पर किसी भी कुंजी की जांच करना चाहते हैं और झूठी मानों के लिए खाता उपयोगिता फ़ंक्शन के लिए इस पंक्ति को मानते हैं:

"key" in object

परिणाम

var obj = {
  a: 1,
  b: 2,
}
"a" in obj // true
"c" in obj // false

यह एनपीएम पैकेज भी देखें: https://www.npmjs.com/package/has-deep-value


यह undefined वापस आ जाएगा।

var aa = {hello: "world"};
alert( aa["hello"] );      // popup box with "world"
alert( aa["goodbye"] );    // popup box with "undefined"

undefined एक विशेष निरंतर मूल्य है। तो आप कह सकते हैं, उदाहरण के लिए

// note the three equal signs so that null won't be equal to undefined
if( aa["goodbye"] === undefined ) {
    // do something
}

यह शायद गायब कुंजी की जांच करने का सबसे अच्छा तरीका है। हालांकि, जैसा कि नीचे दी गई टिप्पणी में बताया गया है, यह सैद्धांतिक रूप से संभव है कि आप वास्तविक मान को undefined रखना चाहते हैं। मुझे ऐसा करने की कभी आवश्यकता नहीं है और मैं किसी कारण से नहीं सोच सकता कि मैं कभी चाहूंगा, लेकिन सिर्फ पूर्णता के लिए, आप ऑपरेटर का उपयोग कर सकते हैं

// this works even if you have {"goodbye": undefined}
if( "goodbye" in aa ) {
    // do something
}

ये उदाहरण डिफेंडर तरीकों के बीच अंतर प्रदर्शित कर सकते हैं। उम्मीद है कि यह आपकी आवश्यकताओं के लिए सही चुनने में आपकी मदद करेगा:

// Lets create object `a` using create function `A`
function A(){};
A.prototype.onProtDef=2;
A.prototype.onProtUndef=undefined;
var a=new A();
a.ownProp = 3;
a.ownPropUndef = undefined;

// Let's try different methods:

a.onProtDef; // 2
a.onProtUndef; // undefined
a.ownProp; // 3
a.ownPropUndef; // undefined
a.whatEver; // undefined
a.valueOf; // ƒ valueOf() { [native code] }

a.hasOwnProperty('onProtDef'); // false
a.hasOwnProperty('onProtUndef'); // false
a.hasOwnProperty('ownProp'); // true
a.hasOwnProperty('ownPropUndef'); // true
a.hasOwnProperty('whatEver'); // false
a.hasOwnProperty('valueOf'); // false

'onProtDef' in a; // true
'onProtUndef' in a; // true
'ownProp' in a; // true
'ownPropUndef' in a; // true
'whatEver' in a; // false
'valueOf' in a; // true (on the prototype chain - Object.valueOf)

Object.keys(a); // ["ownProp", "ownPropUndef"]

वेनिला जेएस

yourObjName.hasOwnProperty(key) : true ? false;

यदि आप यह देखना चाहते हैं कि ऑब्जेक्ट में es2015 में कम से कम एक संपत्ति है या नहीं

Object.keys(yourObjName).length : true ? false

उत्तर:

if ("key" in myObj)
{
    console.log("key exists!");
}
else
{
    console.log("key doesn't exist!");
}

स्पष्टीकरण:

ऑपरेटर जांच करेगा कि वस्तु में कुंजी मौजूद है या नहीं। यदि आपने चेक किया है कि मान अपरिभाषित था: if (myObj["key"] === 'undefined') , तो आप समस्याओं में भाग ले सकते हैं क्योंकि आपके ऑब्जेक्ट में undefined मान के साथ एक कुंजी संभवतः मौजूद हो सकती है।

इसी कारण से, पहले ऑपरेटर का उपयोग करने के लिए यह बहुत बेहतर अभ्यास है और फिर एक बार जब आप पहले से ही जानते हैं तो कुंजी के अंदर मौजूद मान की तुलना करें।


जावास्क्रिप्ट विनाश के साथ नया भयानक समाधान:

var obj = {
    test: "",
    locals: {
        test: "",
        test2: false,
        test3: NaN,
        test4: 0,
        test5: undefined,
        auth: {
            user: "hw"
        }
    }
}

keyExistsOn(obj, "")
> false
keyExistsOn(obj, "locals.test")
> true
keyExistsOn(obj, "locals.test2")
> true
keyExistsOn(obj, "locals.test3")
> true
keyExistsOn(obj, "locals.test4")
> true
keyExistsOn(obj, "locals.test5")
> true
keyExistsOn(obj, "sdsdf")
false
keyExistsOn(obj, "sdsdf.rtsd")
false
keyExistsOn(obj, "sdsdf.234d")
false
keyExistsOn(obj, "2134.sdsdf.234d")
false
keyExistsOn(obj, "locals")
true
keyExistsOn(obj, "locals.")
false
keyExistsOn(obj, "locals.auth")
true
keyExistsOn(obj, "locals.autht")
false
keyExistsOn(obj, "locals.auth.")
false
keyExistsOn(obj, "locals.auth.user")
true
keyExistsOn(obj, "locals.auth.userr")
false
keyExistsOn(obj, "locals.auth.user.")
false
keyExistsOn(obj, "locals.auth.user")
true

जावास्क्रिप्ट विनाश के अन्य उपयोग की जांच करें


"key" in obj

संभवतः ऑब्जेक्ट विशेषता मानों का परीक्षण कर रहा है जो सरणी कुंजी से बहुत अलग हैं






object