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


2963

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

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


2
जावास्क्रिप्ट में सब कुछ (लगभग सब कुछ) एक वस्तु है या एक के रूप में डाली जा सकती है। यहीं पर @PatrickM की तरह छद्म सहयोगी सरणियों का जन्म होता है।
एंड्रयू लार्सन

यह बेंचमार्क jsben.ch/#/WqlIl आपको इस चेक को प्राप्त करने के सबसे सामान्य तरीकों पर एक सिंहावलोकन देता है।
एस्केपनेटस्केप

त्वरित वर्कअराउंड, आमतौर पर मैं इसके लिए जाता हूं property.key = property.key || 'some default value', बस अगर मैं चाहता हूं कि कुंजी इसके कुछ मूल्य के साथ मौजूद है
RGLSV

जवाबों:


4112

अपरिभाषित-नेस की जाँच करना परीक्षण का एक सटीक तरीका नहीं है कि क्या कोई कुंजी मौजूद है। क्या होगा यदि कुंजी मौजूद है लेकिन मूल्य वास्तव में है undefined?

var obj = { key: undefined };
obj["key"] !== undefined // false, but the key exists!

आपको इसके बजाय inऑपरेटर का उपयोग करना चाहिए :

"key" in obj // true, regardless of the actual value

यदि आप जांचना चाहते हैं कि क्या कोई कुंजी मौजूद नहीं है, तो कोष्ठक का उपयोग करना याद रखें:

!("key" in obj) // true if "key" doesn't exist in object
!"key" in obj   // ERROR!  Equivalent to "false in obj"

या, यदि आप ऑब्जेक्ट उदाहरण (और विरासत में मिली संपत्ति) के गुणों के लिए विशेष रूप से परीक्षण करना चाहते हैं, तो उपयोग करें hasOwnProperty:

obj.hasOwnProperty("key") // true

प्रदर्शन विधियों के बीच तुलना के लिए in, hasOwnPropertyऔर कुंजी है undefined, यह मानदंड देखें


83
अपरिभाषित की मैन्युअल रूप से परिभाषित मूल्य वाली संपत्ति होने से बिल्कुल कोई मतलब नहीं है। यह वास्तव में एक ऑक्सीमोरोन होगा।
जोबेत

259
मुझे विश्वास है कि जानबूझकर अपरिभाषित करने के लिए सेट किए गए गुणों के उपयोग के मामले हैं।
एटल गोराल

168
वैध उपयोग मामला: गेको 1.9.1 [फ़ायरफ़ॉक्स 3.5] के पास कोई विंडो नहीं है। गेको 1.9.2 [फ़ायरफ़ॉक्स 3.6] में यह संपत्ति अपरिभाषित है (जब तक हैश नहीं बदल जाती)। हैश इतिहास या ब्राउज़र संस्करण का पता लगाने की सुविधा के लिए, किसी को window.hasOwnProperty ("onhashchange)" का उपयोग करना चाहिए;
सैमगुडी

7
PHP में एक समान समस्या मौजूद है जहाँ null == nonexistent: stackoverflow.com/q/418066/372654 और दुर्भाग्य से, null का वहाँ भी उपयोग है।
ürzgür

80
@joebert सिर्फ इसलिए कि कुछ बकवास है इसका मतलब यह नहीं है कि आप इसे उत्पादन कोड में सामना नहीं करेंगे। कई पुस्तकालय हैं जो निरर्थक बातें करते हैं।
2

298

शीघ्र जवाब

अगर जावास्क्रिप्ट ऑब्जेक्ट या सरणी में कोई विशेष कुंजी मौजूद है, तो मैं कैसे जांच करूं? यदि कोई कुंजी मौजूद नहीं है और मैं इसे एक्सेस करने की कोशिश करता हूं, तो क्या यह गलत होगा? या एक त्रुटि फेंक?

(साहचर्य) सरणी शैली या ऑब्जेक्ट शैली का उपयोग करके एक लापता संपत्ति तक सीधे पहुंचना अपरिभाषित स्थिरांक लौटाएगा ।

ऑपरेटर में धीमी और विश्वसनीय और hasOwnProperty विधि

जैसा कि लोगों ने पहले ही यहां उल्लेख किया है, आपके पास एक "अपरिभाषित" स्थिरांक के साथ जुड़ी संपत्ति के साथ एक वस्तु हो सकती है।

 var bizzareObj = {valid_key:  undefined};

उस मामले में, आप का उपयोग करना होगा hasOwnProperty या में ऑपरेटर अगर कुंजी वास्तव में वहाँ है पता करने के लिए। लेकिन, लेकिन किस कीमत पर?

इसलिए, मैं आपको बताता हूं ...

में ऑपरेटर और hasOwnProperty "तरीकों" का उपयोग जावास्क्रिप्ट में संपत्ति डिस्क्रिप्टर तंत्र (जावा भाषा में जावा प्रतिबिंब के समान) कर रहे हैं।

http://www.ecma-international.org/ecma-262/5.1/#sec-8.10

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

दूसरी ओर, ऑब्जेक्ट विधि या कुंजी को कॉल करना जावास्क्रिप्ट [[प्राप्त करें]] तंत्र का उपयोग करेगा। यह बहुत तेजी से रास्ता है!

बेंचमार्क

http://jsperf.com/checking-if-a-key-exists-in-a-javascript-array

जेएस में प्रमुख पहुंच की तुलना

ऑपरेटर में उपयोग करना
var result = "Impression" in array;

नतीजा था

12,931,832 ±0.21% ops/sec      92% slower 
HasOwnProperty का उपयोग करना
var result = array.hasOwnProperty("Impression")

नतीजा था

16,021,758 ±0.45% ops/sec     91% slower
तत्वों तक सीधे पहुंचना (कोष्ठक शैली)
var result = array["Impression"] === undefined

नतीजा था

168,270,439 ±0.13 ops/sec     0.02% slower 
सीधे तत्वों तक पहुँच (वस्तु शैली)
var result = array.Impression  === undefined;

नतीजा था

168,303,172 ±0.20%     fastest

संपादित करें: किसी संपत्ति को undefinedमूल्य देने का क्या कारण है ?

यह प्रश्न मेरे लिए पहेली है। जावास्क्रिप्ट में, इस तरह की समस्याओं से बचने के लिए अनुपस्थित वस्तुओं के लिए कम से कम दो संदर्भ हैं: nullऔर undefined

nullवह आदिम मूल्य है जो किसी वस्तु के मूल्य के जानबूझकर अनुपस्थिति का प्रतिनिधित्व करता है, या कम शब्दों में, मूल्य की पुष्टि की कमी। दूसरी ओर, undefinedअज्ञात मूल्य (परिभाषित नहीं) है। यदि कोई ऐसी संपत्ति है जिसे बाद में उचित मूल्य के साथ उपयोग किया जाएगा, तो nullइसके बजाय उपयोग के संदर्भ पर विचार करें undefinedक्योंकि प्रारंभिक क्षण में संपत्ति के मूल्य का अभाव होने की पुष्टि की जाती है।

की तुलना करें:

var a = {1: null}; 
console.log(a[1] === undefined); // output: false. I know the value at position 1 of a[] is absent and this was by design, i.e.:  the value is defined. 
console.log(a[0] === undefined); // output: true. I cannot say anything about a[0] value. In this case, the key 0 was not in a[].

सलाह देना

undefinedमूल्यों वाली वस्तुओं से बचें । जब भी संभव हो सीधे जाँच करें और nullसंपत्ति मूल्यों को इनिशियलाइज़ करने के लिए उपयोग करें। अन्यथा, धीमे inऑपरेटर या hasOwnProperty()विधि का उपयोग करें ।

संपादित करें: 12/04/2018 - कहीं भी जारी न करें

जैसा कि लोगों ने टिप्पणी की है, जावास्क्रिप्ट इंजन के आधुनिक संस्करणों (फ़ायरफ़ॉक्स अपवाद के साथ) ने पहुंच गुणों के लिए दृष्टिकोण बदल दिया है। वर्तमान कार्यान्वयन इस विशेष मामले के लिए पिछले एक की तुलना में धीमा है, लेकिन पहुंच कुंजी और ऑब्जेक्ट के बीच अंतर उपेक्षित है।


1
क्या ये सभी तरीके आमतौर पर इस्तेमाल किए जाने वाले ब्राउज़रों में स्वीकार्य हैं, जैसे IE8 +?
जस्टिन

11
बेंचमार्किंग के लिए +1। धन्यवाद, यह ठीक वही जानकारी है जिसकी मुझे आशा थी। कोड लिखने के लिए निश्चित रूप से एक मजबूत तर्क जो कभी भी अपरिभाषित मूल्य को रोकने के लिए एक कुंजी प्रदान नहीं करता है या अपेक्षा करता है ।
TJ कॉम्पटन

मैं उत्सुक था कि अंडरस्कोरजज की () तुलना कैसे की गई है, इसलिए मैंने इसे जेस्पर ( संस्करण 11 ) में जोड़ा । यह धीमे समूह के साथ और hasOwnProperty () में बदल जाता है।
मपिसोट

3
एक कारण जिसे मैं एक हैश मान के लिए अपरिभाषित करूंगा, वह यह है कि मैं वास्तव में हैश से उस संपत्ति की कुंजी को हटाना चाहता था, लेकिन delete hash[key]उसकी तुलना में बहुत धीमी है hash[key] = undefined । बेशक इस मामले में यह मेरे लिए inऑपरेटर की आवश्यकता के लिए कोई मतलब नहीं है , लेकिन यह "हम हमेशा अपरिभाषित मूल्य निर्धारित करने से बचना चाहिए" प्रतिपक्ष के रूप में कार्य करता है।
एलन टैम

1
जैसा कि @ HüseyinYağlı ने उल्लेख किया है, यदि आप jsperf लिंक की जांच करते हैं, तो अधिकांश ब्राउज़र के लिए अलग-अलग तरीकों के बीच प्रदर्शन में काफी बदलाव आया है क्योंकि यह उत्तर मूल रूप से लिखा गया था। फ़ायरफ़ॉक्स उन कुछ में से एक है जो अभी भी सरणी या ऑब्जेक्ट विधियों का उपयोग करके एक महत्वपूर्ण लाभ है, लेकिन कई अन्य ब्राउज़रों के लिए अंतर नगण्य हैं।
15

144

यह वापस आ जाएगी 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। मुझे ऐसा करने की कभी आवश्यकता नहीं है और मैं ऐसा कारण नहीं सोच सकता कि मैं ऐसा क्यों करना चाहता हूँ, लेकिन सिर्फ पूर्णता के लिए, आप inऑपरेटर का उपयोग कर सकते हैं

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

8
क्या होगा यदि कुंजी मौजूद है लेकिन मूल्य वास्तव में अपरिभाषित है?
एटल गोराल जूल

13
अपरिभाषित की तुलना करते समय आपको == के बजाय === का उपयोग करना चाहिए, अन्यथा अशक्त अपरिभाषित के बराबर की तुलना करेगा।
मैथ्यू क्रुमले

10
एली आपका जवाब पूरी तरह से सही नहीं है। क्योंकि वैसे भी (और निश्चित रूप से यह कभी भी नहीं किया जाना चाहिए) अपरिभाषित एक विशेष स्थिर मूल्य नहीं है। वास्तव में, यह एक आरक्षित कीवर्ड नहीं है और आप इसे ओवरराइट कर सकते हैं, आइए उदाहरण के लिए कहें var undefined = 42;। अपरिभाषित सहारा के लिए परीक्षण करते समय आपको हमेशा उपयोग करना चाहिए ((typeof variable) === "undefined")
13

1
@ssice undefinedएक लिखने योग्य संपत्ति कल्पना के अनुसार नहीं है ecma-international.org/ecma-262/5.1/#sec-15.1.1.3
therealrootuser

1
जावास्क्रिप्ट के पुराने संस्करणों में, 'अपरिभाषित' और 'NaN' ऐसे परिवर्तनशील चर थे, जिन्हें अन्य मूल्यों को फिर से परिभाषित या असाइन किया जा सकता था । यह एक बुरी बात थी। इसे ECMAScript 5 में तय किया गया था
jkdev

32

स्वीकार किए जाते हैं जवाब के लिए संदर्भित करता वस्तु । कुंजियों के बजाय डेटा खोजने के लिए ऐरे पर inऑपरेटर का उपयोग करने से सावधान रहें :

("true" in ["true", "false"])
// -> false (Because the keys of the above Array are actually 0 and 1)

किसी ऐरे में मौजूदा तत्वों का परीक्षण करने के लिए: किसी आइटम को जावास्क्रिप्ट सरणी में खोजने के लिए सबसे अच्छा तरीका है?


अच्छी बात है, धन्यवाद। :)
लुकास सूसा

29
"key" in obj

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


यह कोड उस कुंजी के लिए भी सही देगा जो क्लास प्रोटोटाइप पर परिभाषित है: फ़ंक्शन A () {}; A.prototype.b = 2; var a = new A (); फिर एक में 'बी' सच है। जबकि a.hasOwnProperty ('b') निश्चित रूप से गलत है।
अलेक्जेंडर

24

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

  1. !! obj.theProperty
    बूल में मान परिवर्तित करेगा। सभी के लिए TRUE लौटाता है, लेकिन 'गलत' मान देता है
  2. 'theProperty' में obj
    सच वापसी करेंगे अगर संपत्ति मौजूद है, कोई अपने मूल्य बात (यहां तक कि खाली)
  3. obj.hasOwnProperty ('theProperty')
    प्रोटोटाइप चेन की जाँच नहीं करता है। (चूँकि सभी वस्तुओं में St toString ’पद्धति है, इसलिए 1 और 2 उस पर खरे उतरेंगे, जबकि 3 उस पर झूठे वापस आ सकते हैं।)

संदर्भ:

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


!! obj.theProperty विफल रहता है जब मान अपरिभाषित है। Ex:var a = {a : undefined, b : null}; !!a.a **will return false**
ARJUN

15

यदि आप underscore.js लाइब्रेरी का उपयोग कर रहे हैं तो ऑब्जेक्ट / एरे ऑपरेशन सरल हो जाते हैं।

आपके मामले में _.has विधि का उपयोग किया जा सकता है। उदाहरण:

yourArray = {age: "10"}

_.has(yourArray, "age")

सच लौटाता है

परंतु,

_.has(yourArray, "invalidKey")

झूठा लौटता है


15

उत्तर:

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

स्पष्टीकरण:

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

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


12

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

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

// How to use it:
// Searching for keys in Arrays
console.log(keyExists('apple', ['apple', 'banana', 'orange'])); // true
console.log(keyExists('fruit', ['apple', 'banana', 'orange'])); // false

// Searching for keys in Objects
console.log(keyExists('age', {'name': 'Bill', 'age': 29 })); // true
console.log(keyExists('title', {'name': 'Jason', 'age': 29 })); // false

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


6
यह थोड़ा उलझा हुआ लगता है: सबसे पहले, जब एक ऐरे की खोज की जाती है तो यह विधि एक मान के लिए जांच रही है , न कि एक कुंजी के लिए। दूसरी बात, जब आप बिल्ट-इन Array.indexOfविधि का उपयोग कर सकते हैं तो इस तरह से एक सरणी के माध्यम से पुनरावृति क्यों ? (यदि आप एक मूल्य की तलाश कर रहे हैं, तो वह है)
Nick F

9

वेनिला जे.एस.

yourObjName.hasOwnProperty(key) : true ? false;

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

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

7

ईएस 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'));


1
यह ऑब्जेक्ट के गैर-संख्यात्मक गुणों के लिए विफल हो जाएगा।
सिड

@ मुझे कुछ उदाहरण दीजिए।
यूजर

हेयर यू गो। let जोशुआ = {नाम: 'जोशुआ', पता: 'लंदन'}; Object.defineProperty (joshua, 'isMarried', {value: true, enumerable: false); कंसोल.लॉग (Object.keys (joshua) में '' मैरिड ')
सिड

मैं अपने समाधान को अपनी वस्तु पर लागू कर रहा हूं। क्या यह पहले आउटपुट के लिए सही नहीं होना चाहिए? कंसोल.लॉग (Object.keys (joshua) .some (v => v == 'isMarried')); console.log (joshua.isMarried);
सिड

1
मुझे क्षमा करें, लेकिन क्या आपने दूसरे कंसोल स्टेटमेंट के आउटपुट की जांच की? Object.defineProperty डॉट नोटेशन का उपयोग करके संपत्ति सेट करने के बराबर है।
सिड


5

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

"key" in object

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

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

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


4

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

वस्तु के पथ पर मूल्य प्राप्त करता है। यदि हल किया गया मान अपरिभाषित है, तो DefaultValue अपनी जगह पर वापस आ जाता है।

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>


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


4

हालांकि यह जरूरी नहीं है कि अगर कोई कुंजी मौजूद है, तो यह एक मूल्य की सच्चाई की जांच करता है। जो undefinedऔर के nullतहत आते हैं।

Boolean(obj.foo)

यह समाधान मेरे लिए सबसे अच्छा काम करता है क्योंकि मैं टाइपस्क्रिप्ट का उपयोग करता हूं, और इस तरह के तार का उपयोग कर रहा हूं 'foo' in objया obj.hasOwnProperty('foo') यह जांचने के लिए कि क्या कोई कुंजी मौजूद है या नहीं मुझे इंटैलिजेंस प्रदान नहीं करती है।


3

यदि आप किसी भी कुंजी पर किसी भी कुंजी के लिए जाँच करना चाहते हैं और फाल्सी मूल्यों के लिए एक उपयोगिता फ़ंक्शन के लिए इस पंक्ति पर विचार करें:

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

परिणाम

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

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


3
const object1 = {
  a: 'something',
  b: 'something',
  c: 'something'
};

const key = 's';

// Object.keys(object1) will return array of the object keys ['a', 'b', 'c']

Object.keys(object1).indexOf(key) === -1 ? 'the key is not there' : 'yep the key is exist';

3

'एरे' दुनिया में हम कुछ प्रकार की चाबियों के रूप में अनुक्रमित कर सकते हैं। क्या आश्चर्य है कि inऑपरेटर (जो ऑब्जेक्ट के लिए अच्छा विकल्प है) भी सरणियों के साथ काम करता है। गैर-मौजूद कुंजी के लिए दिया गया मान हैundefined

let arr = ["a","b","c"]; // we have indexes: 0,1,2
delete arr[1];           // set 'empty' at index 1
arr.pop();               // remove last item

console.log(0 in arr,  arr[0]);
console.log(1 in arr,  arr[1]);
console.log(2 in arr,  arr[2]);


2

yourArray.indexOf (yourArrayKeyName)> -1

fruit = ['apple', 'grapes', 'banana']

fruit.indexOf('apple') > -1

सच


fruit = ['apple', 'grapes', 'banana']

fruit.indexOf('apple1') > -1

असत्य


0

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

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

-1

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

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

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

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.