Object.is बनाम ===

Question

मैं एक कोड उदाहरण पर ठोकर खाई, जो इस तुलना का उपयोग कर रहा था:

var someVar = 0;
Object.is(false, someVar); //Returns false 

मुझे पता false == 0है trueकि यही कारण है कि हमारे पास है ===।

कैसे Object.isअलग है ===?

Answer 1

===जावास्क्रिप्ट में सख्त तुलना ऑपरेटर कहा जाता है। Object.isऔर सख्त तुलना ऑपरेटर बिल्कुल वैसा ही व्यवहार करता है, सिवाय NaNऔर +0/-0।

MDN से:

Object.is()विधि ===ऑपरेटर के अनुसार समान होने के समान नहीं है । ===ऑपरेटर (और ==साथ ही ऑपरेटर) संख्या मूल्यों -0 और +0 बराबर के रूप में व्यवहार करता है और व्यवहार करता है Number.NaNके रूप में करने के लिए बराबर नहीं NaN।

नीचे दिए गए कोड में ===और के बीच अंतर पर प्रकाश डाला गया है Object.is()।

console.log(+0 === -0); //true
console.log(Object.is(+0, -0)); //false

console.log(NaN === NaN); // false
console.log(Object.is(NaN, NaN)); //true

console.log(Number.NaN === Number.NaN); // false
console.log(Object.is(Number.NaN, Number.NaN)); // true

console.log(NaN === Number.NaN); // false
console.log(Object.is(NaN, Number.NaN)); // true

आप यहां और उदाहरण पा सकते हैं ।

नोट : Object.isECMAScript 6 प्रस्ताव का हिस्सा है और अभी तक व्यापक रूप से समर्थित नहीं है (उदाहरण के लिए यह किसी भी तरह के इंटरनेट एक्सप्लोरर या अन्य ब्राउज़रों के कई पुराने संस्करणों द्वारा समर्थित नहीं है)। हालाँकि आप गैर-ईएस 6 ब्राउज़रों के लिए एक पॉलीफ़िल का उपयोग कर सकते हैं जो ऊपर दिए गए लिंक में पाया जा सकता है।

Comments

उत्तर की पहली पंक्ति "उन्हें NaN और +0 और -0 को छोड़कर बिल्कुल वैसा ही व्यवहार करना चाहिए"।

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

@BenjaminGruenbaum अच्छा सुझाव है। पढ़ने में आसान उत्तर देता है। चीयर्स।

— गुरप्रीत सिंह

@ humble.rumble इस पर चर्चा की गई कि - स्थैतिक विधियां सरल हैं - उनके पास संदर्भ मुद्दे या आदिम मुद्दे नहीं हैं। आपके उदाहरण में उदाहरण के लिए, मैं झूठे की अपेक्षा करता हूं, लेकिन JS के लिए newbies तब से उम्मीद करेगा जब यह एक स्ट्रिंग बॉक्स पर करने से सत्य होगा (और न ही एक स्ट्रिंग आदिम मूल्य) और तुलना एक वस्तु और स्ट्रिंग के बीच होगी - यह बहुत है सूक्ष्म और एक नुकसान है - स्टेटिक्स इन मुद्दों से बचते हैं, स्थैतिक तरीके सरल और उपयोग में आसान होते हैं। .xString

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

@ humble.rumble DOM नोड्स की तुलना करने के लिए, पहले से ही एक ऐसी विधि है, देखें isEqualNode । उदाहरण:document.createElement('div').isEqualNode(document.createElement('div')) === true

— रोब डब्ल्यू

2017 अपडेट: Object.is () अब सभी प्रमुख ब्राउज़रों में व्यापक रूप से समर्थित है।

— स्टर्लिंग बॉर्न

Answer 2

Object.isविनिर्देशन के सेमवैल्यू एल्गोरिथ्म=== का उपयोग करता है , जबकि स्ट्रिक्ट इक्वेलिटी एल्गोरिथम का उपयोग करता है । सख्त समानता एल्गोरिथ्म पर एक नोट अंतर को बुलाता है:

यह एल्गोरिथ्म हस्ताक्षरित शून्य और NaNs के उपचार में सेमवैलू एल्गोरिथम ... से भिन्न होता है।

ध्यान दें कि:

• NaN === NaNगलत है, लेकिन Object.is(NaN, NaN)सच है
• +0 === -0सच है, लेकिन Object.is(+0, -0)गलत है
• -0 === +0सच है, लेकिन Object.is(-0, +0)गलत है

जावास्क्रिप्ट में कम से कम चार प्रकार की "समानता" है:

• "ढीला" ( ==), जहां ऑपरेंड को मैच करने के लिए प्रयास करने के लिए मजबूर किया जाएगा। नियम स्पष्ट रूप से निर्दिष्ट हैं , लेकिन गैर-स्पष्ट हैं। ( "" == 0है true, "true" == trueहै false, ...)।
• "स्ट्रिक्ट" ( ===), जहां अलग-अलग प्रकारों के ऑपरेंड को ज़ब्त नहीं किया जाएगा (और बराबर नहीं होगा), लेकिन नोट के बारे में NaNसकारात्मक और नकारात्मक शून्य देखें।
• समान - जैसा कि ऊपर सूचीबद्ध (द्वारा प्रयोग किया जाता है Object.is)।
• SameValueZero - जैसे SameValueको छोड़कर +0और -0एक ही के बजाय अलग हैं (द्वारा प्रयोग किया जाता Mapचाबी के लिए, और से Array.prototype.includes)।

ऑब्जेक्ट समतुल्यता भी है , जो भाषा या रनटाइम द्वारा प्रदान नहीं की जाती है, लेकिन आमतौर पर इसके रूप में व्यक्त की जाती है: वस्तुओं में समान प्रोटोटाइप, समान गुण होते हैं, और उनकी संपत्ति का मान समान होता है ("उसी" की कुछ उचित परिभाषा द्वारा) )।

---

सेमवैल्यू एल्गोरिथम :

• यदि टाइप (x) टाइप (y) से अलग है, तो गलत लौटें।
• यदि टाइप (x) संख्या है, तो
  • यदि x NaN है और y NaN है, तो सही लौटें।
  • यदि x +0 है और y -0 है, तो गलत लौटें।
  • यदि x -0 है और y +0 है, तो गलत लौटें।
  • यदि x y के समान संख्या मान है, तो सही लौटें।
  • विवरण झूठा है।
• सेमवैल्यूएनॉननंबर (x, y) वापस करें।

... जहां SameValueNonNumber है:

• मुखर: प्रकार (x) संख्या नहीं है।
• जोर: टाइप (x) टाइप (y) के समान है।
• यदि टाइप (x) अपरिभाषित है, तो सही लौटें।
• यदि टाइप (x) शून्य है, तो सही लौटें।
• यदि टाइप (x) स्ट्रिंग है, तो
  • यदि x और y कोड इकाइयों (समान लंबाई और समान सूचकांकों पर समान कोड इकाइयाँ) के समान क्रम हैं, तो वापस लौटें; अन्यथा, झूठे लौटें।
• यदि टाइप (x) बूलियन है, तो
  • यदि x और y दोनों सत्य हैं या दोनों असत्य हैं, तो सत्य लौटें; अन्यथा, झूठे लौटें।
• यदि Type (x) Symbol है, तो
  • यदि x और y दोनों समान प्रतीक मान हैं, तो सही लौटें; अन्यथा, झूठे लौटें।
• यदि x और y समान ऑब्जेक्ट मान हैं, तो सही लौटें। नहीं तो झूठा लौट आता है।

---

सख्त समानता एल्गोरिथम :

1. यदि टाइप (x) टाइप (y) से अलग है, तो गलत लौटें।
2. यदि टाइप (x) संख्या है, तो
   • यदि x NaN है, तो गलत लौटें।
   • यदि y NaN है, तो गलत लौटें।
   • यदि x y के समान संख्या मान है, तो सही लौटें।
   • यदि x +0 है और y -0 है, तो सही लौटें।
   • यदि x -0 है और y +0 है, तो सही लौटें।
   • विवरण झूठा है।
3. सेमवैल्यूएनॉननंबर (x, y) वापस करें।

Answer 3

Object.is = function(v1, v2){
  //test for `-0`
  if(v1 === 0 && v2 === 0) {
    return 1 / v1 === 1 / v2;
  }
  
  //test for `NaN`
  if(v1 !== v1) {
    return v2 !== v2;
  }
  
  //everything else
  return v1 === v2;
}

उपरोक्त पॉलीफ़िल फ़ंक्शन यह दिखाने के लिए है कि कैसे Object.isकाम करता है, किसी के लिए भी जो जानने के इच्छुक हैं। यू-डोंट-नो-जेएस का संदर्भ

Answer 4

सारांश:

Object.is()समारोह तर्क के रूप में 2 मानों का उपयोग करके सच रिटर्न अगर 2 दिए गए मान ठीक उसी हैं, अन्यथा यह अवास्तविक लौटाते हैं।

हमें यह क्यों चाहिये?

आप सोच सकते हैं, हमारे पास पहले से ही ===ऑपरेटर के साथ जावास्क्रिप्ट में सख्त समानता (चेक प्रकार + मूल्य) की जाँच है , हमें इस फ़ंक्शन की आवश्यकता क्यों है? अच्छी तरह से सख्त समानता कुछ मामलों में पर्याप्त नहीं है और वे निम्नलिखित हैं:

console.log(NaN === NaN);   // false
console.log(-0 === +0);     // true

Object.is() इन मूल्यों की तुलना करने में सक्षम होने में हमारी मदद करता है कि क्या वे समान हैं, कुछ सख्त समानता ऑपरेटर नहीं कर सकते हैं।

console.log(Object.is(NaN, NaN));  // true
console.log(Object.is(-0, 0));     // false
console.log(Object.is(+0, +0));    // true
console.log(Object.is(+0, -0));    // false

Answer 5

संक्षेप में, वे समान हैं, लेकिन Object.isचालाक और अधिक सटीक हैं ...

आइए इसे देखें ...

+0 === -0 //true

लेकिन यह पूरी तरह से सही नहीं है क्योंकि यह अनदेखा -और +पहले ...

अब हम उपयोग करते हैं:

Object.is(+0, -0) //false

जैसा कि आप देखते हैं, यह तुलना करने के लिए अधिक सटीक है।

इसके अलावा NaN, सही होने की तरह अधिक काम करता है, जैसा कि कोई भी विचार NaNकरता है।