जावास्क्रिप्ट तुलना में ऑपरेटर (== बनाम ===) का उपयोग किया जाना चाहिए?

Question

मैं जावास्क्रिप्ट के माध्यम से जाने के लिए JSLint का उपयोग कर रहा हूं , और यह एक बयान के अंदर तुलना करने जैसी चीजों को करते समय (तीन बराबर संकेतों के ==साथ) ===(तीन बराबर संकेतों) को बदलने के लिए कई सुझावों को वापस कर रहा है ।idSele_UNVEHtype.value.length == 0if

के ==साथ बदलने के लिए एक प्रदर्शन लाभ है ===?

किसी भी प्रदर्शन सुधार का स्वागत किया जाएगा क्योंकि कई तुलनात्मक ऑपरेटर मौजूद हैं।

यदि कोई प्रकार का रूपांतरण नहीं होता है, तो क्या कोई प्रदर्शन लाभ होगा ==?

Comments

जिनके लिए यह एक ही विषय में रुचि हो सकती है === vs ==, लेकिन PHP में, यहां पढ़ सकते हैं: stackoverflow.com/questions/2401478/why-is-faster-than-in-php/…

— Marco Demaio

बस मामले में किसी को भी 2012 में सोच रहा था: ===है जिस तरह की तुलना में तेजी ==। jsperf.com/comparison-of-comparisons

— Ry-

@ मिनिटेक यह होना चाहिए क्योंकि यह टाइप रूपांतरण नहीं करता है

— उमर कोंटासी

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

— लॉरेंट

यहाँ क्रॉकफ़ोर्ड के जेएस द गुड पार्ट्स की बात की गई है जहाँ वह चर्चा करते हैं ===और ==ऑपरेटरों से कहते हैं: youtube.com/… अगर यह नहीं खेलता है, तो यह 15:20

— बजे है

Answer 1

सख्त समानता ऑपरेटर ( ===) ==किसी भी प्रकार के रूपांतरण को छोड़कर , समान रूप से समानता ऑपरेटर ( ) को समान रूप से व्यवहार करता है, और प्रकार को समान माना जाना चाहिए।

संदर्भ: जावास्क्रिप्ट ट्यूटोरियल: तुलना ऑपरेटर

==ऑपरेटर समानता के लिए तुलना करेंगे किसी भी आवश्यक प्रकार रूपांतरण करने के बाद । ===ऑपरेटर होगा नहीं तो अगर दो मानों नहीं एक ही प्रकार के हैं रूपांतरण करते हैं, ===बस वापस आ जाएगी false। दोनों समान रूप से तेज हैं।

डगलस क्रॉकफोर्ड के उत्कृष्ट जावास्क्रिप्ट को उद्धृत करने के लिए : द गुड पार्ट्स ,

जावास्क्रिप्ट में समानता ऑपरेटरों के दो सेट हैं: ===और !==, और उनके दुष्ट जुड़वां ==और !=। अच्छे लोग उस तरह से काम करते हैं जिस तरह से आप उम्मीद करते हैं। यदि दो ऑपरेंड एक ही प्रकार के हैं और एक ही मूल्य हैं, तो ===उत्पादन trueऔर !==उत्पादन करता है false। जब आप एक ही प्रकार के होते हैं, तो दुष्ट जुड़वाँ सही काम करते हैं, लेकिन यदि वे अलग-अलग प्रकार के होते हैं, तो वे मूल्यों के साथ छेड़छाड़ करने का प्रयास करते हैं। नियम जिसके द्वारा वे ऐसा करते हैं, जटिल और असहनीय हैं। ये कुछ दिलचस्प मामले हैं:

'' == '0'           // false
0 == ''             // true
0 == '0'            // true

false == 'false'    // false
false == '0'        // true

false == undefined  // false
false == null       // false
null == undefined   // true

' \t\r\n ' == 0     // true

परिवर्तनशीलता की कमी चिंताजनक है। मेरी सलाह है कि कभी भी दुष्ट जुड़वां बच्चों का उपयोग न करें। इसके बजाय, हमेशा उपयोग करें ===और !==। सभी तुलना बस ऑपरेटर के falseसाथ उत्पादन दिखाया ===।

---

अपडेट करें:

टिप्पणियों में @Casebash द्वारा और वस्तुओं से संबंधित @Phillipe Laybaert के उत्तर में एक अच्छा बिंदु लाया गया था । वस्तुओं के लिए, ==और ===एक दूसरे के साथ लगातार कार्य करें (एक विशेष मामले को छोड़कर)।

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

विशेष मामला तब होता है जब आप किसी आदिम की तुलना उस वस्तु के साथ करते हैं जो उसी आदिम का मूल्यांकन करती है, इसके toStringया valueOfविधि के कारण । उदाहरण के लिए, स्ट्रिंग स्ट्रिंग की तुलना पर विचार करें जो एक स्ट्रिंग ऑब्जेक्ट के साथ बनाई गई है जो Stringकंस्ट्रक्टर का उपयोग कर बनाई गई है ।

"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

यहां ==ऑपरेटर दो वस्तुओं के मूल्यों की जांच कर रहा है और वापस लौट रहा है true, लेकिन ===यह देख रहा है कि वे एक ही प्रकार के नहीं हैं और वापस लौट रहे हैं false। कौनसा सही है? यह वास्तव में आप क्या तुलना करने की कोशिश कर रहे हैं पर निर्भर करता है। मेरी सलाह है कि आप इस प्रश्न को पूरी तरह से दरकिनार कर दें और Stringस्ट्रिंगर से स्ट्रिंग ऑब्जेक्ट्स बनाने के लिए कंस्ट्रक्टर का उपयोग न करें ।

संदर्भ
http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3

Comments

=== तेज नहीं है यदि प्रकार समान हैं। यदि प्रकार समान नहीं हैं, तो === जल्दी हो जाएगा क्योंकि यह रूपांतरण करने की कोशिश नहीं करेगा।

— छिपकली का बिल

=== कभी भी धीमी नहीं होगी == वे दोनों टाइप चेकिंग करते हैं, इसलिए === की तुलना में कुछ भी अतिरिक्त नहीं करते हैं =, लेकिन टाइप चेक === को जल्दी ही बाहर निकलने की अनुमति दे सकता है जब टाइप समान नहीं होते हैं।

— छिपकली

सभी == /! = को === /! == से बदलने से js फ़ाइल का आकार बढ़ जाता है, इसे लोड होने में अधिक समय लगेगा। :)

— मार्को डेमायो

"... नियम, जिसके द्वारा वे करते हैं कि जटिल और असहनीय हैं ..." अब ऐसे बयान आपको प्रोग्रामिंग करते समय बहुत सुरक्षित महसूस करते हैं ...

— जोहान

क्रॉकफोर्ड से: "सकारात्मकता की कमी चिंताजनक है।" यदि आप सॉफ़्टवेयर का विकास करते हैं और तुलनात्मक संचालक के अलार्म में ट्रांज़िटिविटी की कमी नहीं पाते हैं, या यदि गति की तुलना == और === या फ़ाइल आकार / लोड समय के बीच तुलनात्मक ऑपरेटर के व्यवहार के सकर्मक निर्धारण पर आपके दिमाग में पूर्वता है, तो आप वापस जाने और शुरू करने की आवश्यकता हो सकती है।

— जिंगलेथुला

Answer 2

==ऑपरेटर ( समानता ) का उपयोग करना

true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

===ऑपरेटर ( पहचान ) का उपयोग करना

true === 1; //false
"2" === 2;  //false

इसका कारण यह है कि समानता ऑपरेटर ==प्रकार की जबरदस्ती करता है , जिसका अर्थ है कि दुभाषिया अंतर्निहित रूप से तुलना करने से पहले मूल्यों को बदलने की कोशिश करता है।

दूसरी ओर, पहचान ऑपरेटर ===प्रकार की ज़बरदस्ती नहीं करता है , और इस तरह तुलना करते समय मूल्यों को परिवर्तित नहीं करता है, और इसलिए यह तेज है (जैसा कि यह जेएस बेंचमार्क परीक्षण के अनुसार ) यह एक कदम को छोड़ देता है।

Comments

@ शेप्ड बंदर: मूल्य प्रकारों (संख्या, बूलियन, ...) के लिए नहीं

— फिलिप लेबेर्ट

के बाद से कोई भी नहीं जावास्क्रिप्ट समानता तालिका उल्लेख किया गया है, यहाँ यह है: dorey.github.io/JavaScript-Equality-Table

— जलते

पहले कथन में, क्या आप सुनिश्चित हैं कि 'सत्य' को 1 में बदल दिया गया है और 1 को सत्य में परिवर्तित नहीं किया गया है?

— Shadi Namrouti

"समानता" और "पहचान" शब्द कहां से आते हैं? मानक उन शब्दों का उपयोग नहीं करता है। इसे =="अमूर्त समानता" कहते हैं और इसे ==="सख्त समानता" कहते हैं। ==किसी भी प्रकार की "समानता" को बुलावा देना IMHO भयानक है, क्योंकि यह सकर्मक नहीं है, लेकिन क्यों विचित्र है? मैं हालांकि "पहचान" के साथ अधिक मुद्दा लेता हूं; मुझे लगता है कि यह शब्द बहुत भ्रामक है, हालांकि यह "काम करता है।" लेकिन गंभीरता से, "पहचान" शब्द किसने गढ़ा? मैं मानक खोजता हूं और उसे खोज नहीं पाया।

— रे तोल

"पहचान" बहुत गलत शब्द है। मेरे द्वारा उपयोग की जाने वाली सभी भाषाओं में पहचान की तुलना एक ही वस्तु में एक का अर्थ है , यानी दो संदर्भ चर केवल समान संस्थाओं के लिए नहीं, बल्कि एक ही इकाई की ओर इशारा कर रहे हैं ।

— Inigo

Answer 3

==और के बीच समानता की तुलना का एक दिलचस्प सचित्र चित्रण ===।

स्रोत: http://dorey.github.io/JavaScript-Equality-Table/

---

var1 === var2

===जावास्क्रिप्ट समानता परीक्षण के लिए उपयोग करते समय, सब कुछ जैसा है। मूल्यांकन किए जाने से पहले कुछ भी परिवर्तित नहीं होता है।

---

var1 == var2

==जावास्क्रिप्ट समानता परीक्षण के लिए उपयोग करते समय, कुछ फंकी रूपांतरण होते हैं।

कहानी का नैतिक:

===जब तक आप अपने साथ होने वाले रूपांतरणों को पूरी तरह से नहीं समझ लेते, तब तक उपयोग करें ==।

Comments

@mfeineis आपका मतलब === या! == के बजाय == या! = है। नए कोडर्स को भ्रमित नहीं करना चाहते;)

— katalin_2003

तीन बराबरी का उपयोग करने के मेरे अनुभव से समस्याएं पैदा हो सकती हैं और जब तक पूरी तरह से समझा नहीं जाता है, तब तक बचा जाना चाहिए। दो बराबर परिणाम बेहतर परिणाम पैदा करते हैं क्योंकि 99% मैं वास्तव में नहीं चाहता कि प्रकार समान हों।

— विस्कॉन

@vsync: यदि आप वास्तव में नहीं चाहते हैं कि प्रकार समान हों , तो आपको तीन बराबर का उपयोग करना चाहिए !

— एसएनजी

एक अपवाद: आप सुरक्षित रूप x == nullसे जाँच कर सकते हैं कि क्या xहै nullया नहीं undefined।

— एंडी

@ user648026: यह सवाल बनाम समानता की तुलना के बारे में है । ऊपरी और निचले मामलों वैसे भी असमान हैं, और वापस आ जाएगी दोनों के साथ और ऑपरेटरों। इसके अलावा, कीवर्ड , , , , जे एस में केवल एक ही मामले में मौजूद हैं, और ऊपरी या मिश्रित मामलों में इस्तेमाल नहीं किया जा सकता। =====false=====truefalseundefinednullInfinity

— SNag

Answer 4

यहाँ उत्तर में, मैं किस बारे में कुछ भी नहीं पढ़ा था बराबर साधन। कुछ कहेंगे कि ===इसका मतलब समान और समान है , लेकिन यह वास्तव में सच नहीं है। इसका वास्तव में मतलब है कि दोनों ऑपरेंड एक ही ऑब्जेक्ट को संदर्भित करते हैं , या वैल्यू टाइप के मामले में , एक ही वैल्यू है ।

तो, चलो निम्नलिखित कोड लेते हैं:

var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

मुझे भी:

var a = { x: 1, y: 2 };
var b = { x: 1, y: 2 };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

या और भी:

var a = { };
var b = { };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

यह व्यवहार हमेशा स्पष्ट नहीं होता है। समान होने और एक ही प्रकार के होने से कहानी अधिक है।

नियम है:

मान प्रकारों (संख्याओं) के लिए:
a === b यदि सही हैaऔरbउसी मूल्य के हैं और उसी प्रकार के हैं

संदर्भ प्रकार के लिए:
a === b रिटर्न सच अगरaऔरbसंदर्भ में ठीक उसी वस्तु

स्ट्रिंग्स के लिए:
a === b यदि यह सच हैaऔरbदोनों स्ट्रिंग्स हैं और एक ही अक्षर हैं

---

स्ट्रिंग्स: विशेष मामला ...

स्ट्रिंग मूल्य प्रकार नहीं हैं, लेकिन जावास्क्रिप्ट में वे मूल्य प्रकारों की तरह व्यवहार करते हैं, इसलिए वे "समान" होंगे जब स्ट्रिंग में वर्ण समान होते हैं और जब वे समान लंबाई के होते हैं (जैसा कि तीसरे नियम में समझाया गया है)

अब यह दिलचस्प हो गया है:

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

लेकिन यह कैसे ?:

var a = new String("123");
var b = "123";

alert(a === b); // returns false !! (but they are equal and of the same type)

मुझे लगा कि तार मूल्य प्रकार की तरह व्यवहार करते हैं? खैर, यह निर्भर करता है कि आप किससे पूछते हैं ... इस मामले में ए और बी एक ही प्रकार के नहीं हैं। aप्रकार का है Object, जबकि bप्रकार का है string। बस याद रखें कि Stringकंस्ट्रक्टर का उपयोग करके एक स्ट्रिंग ऑब्जेक्ट बनाने से कुछ ऐसा प्रकार बनता है जो अधिकांश समयObject स्ट्रिंग के रूप में व्यवहार करता है ।

Comments

एक्टिवा: मैं स्पष्ट करूंगा, कि स्ट्रिंग्स केवल इतने ही हैं जब वे शाब्दिक हैं। नया स्ट्रिंग ("एबीसी") === "एबीसी" गलत है (मेरे शोध के अनुसार)।

— लॉरेंस Dol

new Number() == "0"। फ़ायरफ़ॉक्स में भी:(function(){}) == "function () {\n}"

— थॉमस एडिंग

क्यों समझाने के लिए धन्यवाद new String("123") !== "123"। वे विभिन्न प्रकार के होते हैं। सरल, अभी तक भ्रामक।

— स्टाइलफाइंग

Stringवस्तुएं तार के रूप में व्यवहार करती हैं जैसे कोई अन्य वस्तु । new Stringकभी भी उपयोग नहीं किया जाना चाहिए, क्योंकि यह वास्तविक तार नहीं बनाता है। एक वास्तविक स्ट्रिंग और बिना स्ट्रिंग Stringफ़ंक्शन के साथ बनाया जा सकता है या बिना किसी फ़ंक्शन के कॉल कर सकता है new, उदाहरण के लिए:String(0); //"0", Real string, not an object

— Esailija

लेकिन आपके द्वारा विस्तृत किए गए मामलों में, ऑपरेटर "==" बिल्कुल वैसा ही व्यवहार करता है।

— यारोन लेवी

Answer 5

मुझे यह परामर्श जोड़ने दें:

यदि संदेह है, तो विनिर्देश पढ़ें !

ECMA-262 एक स्क्रिप्टिंग भाषा के लिए विनिर्देश है जिसमें जावास्क्रिप्ट एक बोली है। निश्चित रूप से यह अधिक मायने रखता है कि सबसे महत्वपूर्ण ब्राउज़र एक गूढ़ परिभाषा की तुलना में कैसे व्यवहार करते हैं कि किसी चीज़ को कैसे नियंत्रित किया जाना चाहिए। लेकिन यह समझने में मददगार है कि नया स्ट्रिंग ("ए")! == "ए" ।

कृपया मुझे समझाएं कि इस प्रश्न को स्पष्ट करने के लिए विनिर्देश कैसे पढ़ें। मैं देखता हूं कि इस बहुत पुराने विषय में किसी के पास बहुत अजीब प्रभाव का जवाब नहीं था। इसलिए, यदि आप एक विनिर्देश पढ़ सकते हैं, तो इससे आपको अपने पेशे में काफी मदद मिलेगी। यह एक अर्जित कौशल है। तो, चलो जारी रखें।

=== के लिए पीडीएफ फाइल को खोजना मुझे विनिर्देशन के पृष्ठ 56 पर लाता है: 11.9.4। सख्त समान संचालक (===) , और विशिष्टताओं के माध्यम से मैं खोजने के बाद:

11.9.6 सख्त समानता की तुलना एल्गोरिथ्म
तुलना x === y, जहां x और y मान हैं, सही या गलत का उत्पादन करता है । इस तरह की तुलना निम्न प्रकार से की जाती है:
  1. यदि टाइप (x) टाइप (y) से भिन्न है, तो गलत लौटें ।
  2. यदि टाइप (x) अपरिभाषित है, तो सही लौटें ।
  3. यदि टाइप (x) शून्य है, तो सही लौटें ।
  4. यदि टाइप (x) नंबर नहीं है, तो चरण 11 पर जाएँ।
  5. यदि x NaN है , तो गलत लौटें ।
  6. यदि y NaN है , तो गलत लौटें ।
  7. यदि x y के समान संख्या मान है, तो सही लौटें ।
  8. यदि x +0 है और y x0 है, तो सही लौटें ।
  9. यदि x If0 है और y +0 है, तो सही लौटें ।
  10. झूठे लौटना ।
  11. यदि टाइप (x) स्ट्रिंग है, तो x और y अक्षर के समान क्रम (समान पदों में समान लंबाई और समान वर्ण) हैं तो सही लौटें ; अन्यथा, झूठे लौटें ।
  12. अगर प्रकार (एक्स) बूलियन है, लौटने सच यदि x और y दोनों कर रहे हैं सच या दोनों झूठी ; अन्यथा, झूठे लौटें ।
  13. सच्चा लौटेंयदि x और y एक ही वस्तु को संदर्भित करते हैं या यदि वे एक दूसरे से जुड़ी हुई वस्तुओं को देखें (13.1.2 देखें)। नहीं तो झूठा लौट आता है ।

दिलचस्प चरण 11 है। हाँ, स्ट्रिंग को मूल्य प्रकार के रूप में माना जाता है। लेकिन यह स्पष्ट नहीं करता है कि नया स्ट्रिंग ("ए") क्यों ! == "ए" । क्या हमारे पास ECMA-262 के अनुरूप ब्राउज़र नहीं है?

इतना शीघ्र नही!

चलो ऑपरेंड के प्रकारों की जांच करते हैं। टाइपोफ़ () में लपेटकर अपने लिए इसे आज़माएं । मुझे लगता है कि नया स्ट्रिंग ("ए") एक वस्तु है, और चरण 1 का उपयोग किया जाता है: यदि प्रकार भिन्न हैं तो झूठे वापस करें ।

यदि आप आश्चर्य करते हैं कि नया स्ट्रिंग ("ए") एक स्ट्रिंग क्यों नहीं लौटाता है, तो विनिर्देशन पढ़ने वाले कुछ व्यायाम के बारे में कैसे? मज़े करो!

---

Aidiakapi ने नीचे टिप्पणी में यह लिखा है:

विनिर्देशन से

11.2.2 नया ऑपरेटर :

यदि प्रकार (निर्माता) ऑब्जेक्ट नहीं है, तो TypeError अपवाद फेंकें।

दूसरे शब्दों के साथ, यदि स्ट्रिंग टाइप ऑब्जेक्ट का नहीं होगा, तो इसका उपयोग नए ऑपरेटर के साथ नहीं किया जा सकता है।

नया हमेशा एक वस्तु देता है, यहां तक ​​कि स्ट्रिंग निर्माणकर्ताओं के लिए भी। और अफसोस! स्ट्रिंग्स के लिए मान शब्दार्थ (चरण 11 देखें) खो गया है।

और अंत में इसका अर्थ है: नया स्ट्रिंग ("ए"! == "ए" ।

Comments

प्रकार (x) का परिणाम टाइपोफ के समान है?

— डीएफआर

@ हंसी के साथ मैं व्यवहार के बारे में चिंता को ठीक से नहीं समझता new String('x'), क्योंकि मैंने कभी भी जंगली में कोई कोड नहीं देखा है जो आदिम आवरण वस्तुओं का उपयोग करता है, और मुझे नहीं लगता कि इसके लिए बहुत अच्छे कारण हैं, खासकर इन दिनों नहीं। क्या आपने कभी उस कोड का सामना किया है जो करता है?

— एंडी

@ और समस्या दुर्भावनापूर्ण है या केवल थर्ड-पार्टी कोड है, तो आप यह नहीं मान सकते कि कोई उपयोग नहीं करता है new String()।

— नागवार

यदि यह टेढ़ा है, तो === यह है कि आप कैसे पता लगाएंगे। यदि यह दुर्भावनापूर्ण है, तो मुझे लगता new String()है कि शायद आपकी चिंताएं कम से कम हों। मैं सिद्धांत में चिंता को समझता हूं, लेकिन फिर, क्या आपके पास कोई वास्तविक दुनिया के उदाहरण हैं? मेरे लिए यह पुरानी चिंता की तरह है कि कोई undefinedअन्य मूल्य निर्धारित कर सकता है ।

— एंडी

मुझे नहीं पता कि आपको यह कहां मिला है, लेकिन चरण 2 में आपका तुलनात्मक एल्गोरिथ्म गलत हो गया है। खंड "7.2.15 सख्त समानता तुलना" पहले यह जांचता है कि क्या प्रकार समान हैं, यदि हां वे संख्या हैं या नहीं। यदि नहीं, तो अनुभाग "7.2.12 सामवैल्यूएननंबर (x, y)" का उपयोग किया जाता है।

— रस्टी कोर

Answer 6

PHP और जावास्क्रिप्ट में, यह एक सख्त समानता ऑपरेटर है। जिसका अर्थ है, यह दोनों प्रकार और मूल्यों की तुलना करेगा।

Comments

@ डेविड: सही है। इसलिए यह उत्तर गलत है (या गलत भी है)

— फिलिप लेबेर्ट

@ डेविड var a = {}, b = {}; a == bझूठे लौटे।

— nyuszika7h

हां: एक ही प्रकार और मूल्य वाली दो अलग-अलग वस्तुएं झूठी तुलना करती हैं, अर्थात यह उत्तर गलत है। इसमें 50 अपवोट क्यों है?

— एलेक्सिस

मुझे एहसास है कि यह पुराना है, लेकिन यह स्पष्ट करने के लिए कि यह उत्तर अभी भी "सही" क्यों है क्योंकि उदाहरण में है var a = {}, b = {};जबकि दोनों aऔर bवास्तव में दोनों एक वस्तु हैं, लेकिन वे एक ही मूल्य नहीं हैं , तकनीकी रूप से बोल रहे हैं। वे अलग - अलग उदाहरण हैं। ध्यान दें कि उदाहरणों की तुलना करना आदिमों की तुलना करने से भिन्न व्यवहार करता है। जो शायद इस भ्रम में जोड़ता है। यदि आप आदिम डेटा प्रकारों के उदाहरण संस्करण का उपयोग करते हैं तो आपको समान तुलनात्मक व्यवहार दिखाई देगा। जैसे new String('asdf')या new Number(5)। Ex: new Number(5) == new Number(5)गलत है, भले ही वे एक ही मूल्य रखते हैं।

— नॉर्मन ब्रेउ

हम सभी यह भूल जाते हैं कि किसी वस्तु का संदर्भ वास्तव में एक वैल्यू टाइप है, क्योंकि यह एक मेमोरी स्लॉट का सूचक है। ऑब्जेक्ट तुलना "ऑब्जेक्ट के मूल्य" की तुलना नहीं कर रहा है, लेकिन क्या दोनों पॉइंटर्स समान हैं, जिसका मतलब है कि वे एक ही मेमोरी स्लॉट का संदर्भ देते हैं। प्रकारों की तुलना करने में यह बहुत ही सूक्ष्म अंतर है, क्योंकि "===" ऑपरेटर को वास्तव में "यदि प्रकार, मान और स्मृति में ऑब्जेक्ट के संदर्भ समान हैं" कहने की आवश्यकता है।

— स्टोकली

Answer 7

मैंने फायरबग के साथ फ़ायरबग में इस तरह कोड का उपयोग करके इसका परीक्षण किया :

console.time("testEquality");
var n = 0;
while(true) {
    n++;
    if(n==100000) 
        break;
}
console.timeEnd("testEquality");

तथा

console.time("testTypeEquality");
var n = 0;
while(true) {
    n++;
    if(n===100000) 
        break;
}
console.timeEnd("testTypeEquality");

मेरे परिणाम (प्रत्येक और औसतन पाँच बार परीक्षण किए गए):

==: 115.2
===: 114.4

तो मैं कहूंगा कि मिनीस्कुल अंतर (यह 100000 पुनरावृत्तियों से अधिक है, याद रखें) नगण्य है। प्रदर्शन करने का कोई कारण नहीं है ===। प्रकार की सुरक्षा (अच्छी तरह से, जितना सुरक्षित आप जावास्क्रिप्ट में प्राप्त करने जा रहे हैं), और कोड की गुणवत्ता है।

Comments

प्रकार की सुरक्षा से अधिक आप तार्किक शुद्धता चाहते हैं - कभी-कभी आप चाहते हैं कि ==असहमत होने पर चीजें सत्य हो ।

— rpjohnst

अब, ==ऑपरेटर के लिए वास्तविक प्रकार के तालमेल होने पर ये तुलना कैसे करते हैं ? याद रखें, कि जब एक प्रदर्शन को बढ़ावा मिलता है।

— ह्यूबर्ट ओजी

केवल भिन्न प्रकार की असमानता की जांच करने के लिए पूर्वोक्त कारणों से ठीक से परीक्षण किए जाने पर मुख्य अंतर। jsfiddle.net/4jhuxkb2

— डग मोर्रो

आप ऑपरेशंस में इस तरह के प्रदर्शन को मापते हैं / दूसरा, एक ब्राउजर में एक भी टेस्ट नहीं (कंसोल में लगभग 5% मार्केट शेयर के साथ) कंसोल.टाइम () का उपयोग करते हुए एक टेस्ट का उपयोग करते हुए जो टाइप कॉर्शन (संपूर्ण कारण) नहीं लेता है यह धीमा है) खाते में। यह पूरी तरह से अर्थहीन परीक्षा है। आप सही है कि प्रदर्शन कारण उपयोग करने के लिए नहीं है ===से अधिक ==है, लेकिन आप गलत है कि उनके प्रदर्शन अनिवार्य रूप से बराबर है और है कि आप इस परीक्षण है कि साबित होता है लगता होगा, और कहा कि कई अन्य लोग सहमत हुए, पूरी तरह से मेरे लिए बेतुका है।

— स्टीफन एम इरविंग

Answer 8

जावास्क्रिप्ट में इसका अर्थ समान मूल्य और प्रकार है।

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

4 == "4" // will return true

परंतु

4 === "4" // will return false 

Answer 9

=== ऑपरेटर एक सख्त तुलना ऑपरेटर कहा जाता है, यह करता है से अलग == ऑपरेटर।

आओ हम 2 vars a और b लेते हैं।

के लिए "एक == ख" होने के लिए सच ए और बी की जरूरत के लिए मूल्यांकन करने के लिए एक ही मूल्य ।

"A === b" के मामले में a और b का समान मान होना चाहिए और साथ ही इसका सही मूल्यांकन करने के लिए भी यही प्रकार होना चाहिए ।

निम्नलिखित उदाहरण लें

var a = 1;
var b = "1";

if (a == b) //evaluates to true as a and b are both 1
{
    alert("a == b");
}

if (a === b) //evaluates to false as a is not the same type as b
{
    alert("a === b");
}

संक्षेप में ; == ऑपरेटर का उपयोग उन स्थितियों में सही मूल्यांकन कर सकता है जहाँ आप नहीं चाहते कि === ऑपरेटर का उपयोग करना सुरक्षित हो।

90% उपयोग परिदृश्य में यह कोई फर्क नहीं पड़ता कि आप किसका उपयोग करते हैं, लेकिन जब आप एक दिन कुछ अप्रत्याशित व्यवहार प्राप्त करते हैं तो अंतर को जानना आसान होता है।

Answer 10

==इतना अप्रत्याशित क्यों है?

जब आप खाली स्ट्रिंग ""की संख्या शून्य से तुलना करते हैं तो आपको क्या मिलता है 0?

true

हां, यह ==एक खाली स्ट्रिंग के अनुसार सही है और संख्या शून्य एक ही समय है।

और यह वहाँ समाप्त नहीं होता है, यहाँ एक और एक है:

'0' == false // true

सरणियों के साथ चीजें वास्तव में अजीब हो जाती हैं।

[1] == true // true
[] == false // true
[[]] == false // true
[0] == false // true

फिर तार के साथ निराई

[1,2,3] == '1,2,3' // true - REALLY?!
'\r\n\t' == 0 // true - Come on!

ये और ख़राब हो जाता है:

कब बराबर नहीं के बराबर है?

let A = ''  // empty string
let B = 0   // zero
let C = '0' // zero string

A == B // true - ok... 
B == C // true - so far so good...
A == C // **FALSE** - Plot twist!

मुझे फिर वही बात कहना है:

(A == B) && (B == C) // true
(A == C) // **FALSE**

और यह सिर्फ पागल सामान है जो आपको आदिम के साथ मिलता है।

जब आप ==वस्तुओं का उपयोग करते हैं तो यह पागल का एक नया स्तर होता है।

इस बिंदु पर आपकी सोच ...

ऐसा क्यों होता है?

ठीक है क्योंकि यह "ट्रिपल बराबर" ( ===) के विपरीत है जो सिर्फ यह जांचता है कि क्या दो मान समान हैं।

==अन्य सामान की एक पूरी गुच्छा करता है ।

यह फ़ंक्शन के लिए विशेष हैंडलिंग है, नल, अपरिभाषित, तार के लिए विशेष हैंडलिंग, आप इसे नाम देते हैं।

यह बहुत निराला है।

वास्तव में, यदि आप एक फ़ंक्शन लिखने की कोशिश करते हैं जो ऐसा ==करता है तो यह कुछ इस तरह दिखाई देगा:

function isEqual(x, y) { // if `==` were a function
    if(typeof y === typeof x) return y === x;
    // treat null and undefined the same
    var xIsNothing = (y === undefined) || (y === null);
    var yIsNothing = (x === undefined) || (x === null);

    if(xIsNothing || yIsNothing) return (xIsNothing && yIsNothing);

    if(typeof y === "function" || typeof x === "function") {
        // if either value is a string 
        // convert the function into a string and compare
        if(typeof x === "string") {
            return x === y.toString();
        } else if(typeof y === "string") {
            return x.toString() === y;
        } 
        return false;
    }

    if(typeof x === "object") x = toPrimitive(x);
    if(typeof y === "object") y = toPrimitive(y);
    if(typeof y === typeof x) return y === x;

    // convert x and y into numbers if they are not already use the "+" trick
    if(typeof x !== "number") x = +x;
    if(typeof y !== "number") y = +y;
    // actually the real `==` is even more complicated than this, especially in ES6
    return x === y;
}

function toPrimitive(obj) {
    var value = obj.valueOf();
    if(obj !== value) return value;
    return obj.toString();
}

अच्छा तो इसका क्या मतलब है?

इसका मतलब ==जटिल है।

क्योंकि यह जटिल है यह जानना मुश्किल है कि जब आप इसका उपयोग करते हैं तो क्या होने वाला है।

जिसका मतलब है कि आप बग को खत्म कर सकते हैं।

तो कहानी का नैतिक है ...

अपने जीवन को कम जटिल बनाओ।

के ===बजाय का उपयोग करें ==।

समाप्त।

Comments

आप looseEqualगलत है Function == Function.toString()सच है, लेकिन looseEqual(Function, Function.toString())गलत है। सुनिश्चित नहीं हैं कि आप शुरुआत में फ़ंक्शंस को फ़िल्टर क्यों करते हैं।

— ओरोल

@ आप सही थे, मैंने उस खाते के लिए कोड को अपडेट कर दिया, मेरे परीक्षणों के आधार पर FYI करना "फ़ंक्शन" के लिए फ़िल्टर को हटाने के लिए पर्याप्त नहीं था, इसके बजाय "फ़ंक्शन" को पूरी तरह से अलग करना था।

— लुइस पेरेज़

ध्यान रखें कि युक्ति अलग-अलग कार्यों का इलाज नहीं करती है, वे सिर्फ वस्तुएं हैं। यह समस्या प्रतीत होती है कि आप typeof x === "object"जाँच करते हैं कि क्या यह एक वस्तु है, लेकिन 'टाइपऑफ़ केवल गैर-शून्य प्राइमेटिक्स के लिए काम करता है। यदि आप कोई वस्तु है तो जाँच करने के लिए उचित तरीकों की

— Oriol

मैंने फ़ंक्शन और ऑब्जेक्ट्स को एक ही मानने की कोशिश की, लेकिन पाया कि वे परिणाम गलत थे। उदाहरण के लिए यदि फ़ंक्शन को ऑब्जेक्ट्स की तरह व्यवहार किया गया था, तो किसी फ़ंक्शन के साथ किसी फ़ंक्शन की तुलना करना जो कि valueOf () या toString () फ़ंक्शन से मेल खाता है जो फ़ंक्शन से मेल खाता है, लेकिन वास्तव में ऐसा नहीं होता है। उदाहरण: (function blah() { console.log("test"); }) != {valueOf:function(){return "function blah() { console.log(\"test\"); }";}}- इस जेएस फिडेल को देखें जो सभी परीक्षण चलाता है: jsfiddle.net/luisperezphd/7k6gcn6g (वहाँ 1,225 परीक्षण क्रमांक)

— लुइस पेरेज

आप सही हैं, महान अवलोकन करते हैं, यह मुख्य बिंदु पर जोर देता ==है जो बहुत सारी चीजें करता है जिससे परिणामों का अनुमान लगाना बहुत मुश्किल हो ===जाता है जबकि अधिक सरल और पूर्वानुमान है जो मुख्य कारणों में ===से एक है अनुशंसित विकल्प। (मैं आपकी बात का उल्लेख करते हुए उत्तर में एक नोट

— लुइस पेरेज़

Answer 11

===चेकों ही पक्षों में बराबर हैं प्रकार के साथ ही मूल्य ।

---

उदाहरण:

'1' === 1 // will return "false" because `string` is not a `number`

आम उदाहरण:

0 == ''  // will be "true", but it's very common to want this check to be "false"

एक और आम उदाहरण:

null == undefined // returns "true", but in most cases a distinction is necessary

---

कई बार एक untyped जाँच क्योंकि आप अगर यह मान है परवाह नहीं है आसान हो जाएगा undefined, null, 0 या""

Comments

यह भी,'string' !== 'number'

— होमर

Answer 12

कठोर समानता / तुलना '===' के लिए जावास्क्रिप्ट निष्पादन प्रवाह आरेख

गैर सख्त समानता / तुलना '==' के लिए जावास्क्रिप्ट निष्पादन प्रवाह आरेख

Comments

मुझे समझ में नहीं आता कि stringतीर बड़े ग्रे बॉक्स की ओर क्यों इशारा कर रहा है, क्या इसका मतलब यह है कि इंटरप्रेटर एक नंबर पर स्ट्रिंग को कास्टिंग कर रहा है?

— विस्कॉन्सिन

@vsync यह ग्रे बॉक्स के भीतर स्ट्रिंग विकल्प की ओर इशारा करता है अर्थात स्ट्रिंग -> # || NaN। जावास्क्रिप्ट एक प्रकार की स्क्रिप्ट भाषा नहीं है, अर्थात मूल रूप से इसमें किसी भी प्रकार का चर हो सकता है। तो, यह उस ग्रे बॉक्स को इंगित करता है।

— समर पांडा

मैंने बस पूछा कि क्या यह कास्टिंग उद्देश्यों के लिए है क्योंकि इसे stringएक प्रकार की तुलना में माना जाता है number, इसलिए इंटरट्रेटर इस बात पर ध्यान देता है कि स्ट्रिंग की तुलना किस आधार पर की जानी चाहिए और उसके अनुसार स्ट्रिंग डाली जाए?

— विस्कॉन्सिन

बड़ा ग्रे बॉक्स वह है जो ToNumberविभिन्न प्रकारों को दिए जाने पर वापस आ जाएगा, इसलिए यदि इसे एक तार दिया जाता है तो यह केवल अंतिम विकल्प का चयन करेगा (और इसे एक संख्या में बदल देगा)। ==का उपयोग करता है ToNumberकेवल मामलों में string == numberया boolean == anything(और केवल पर ऊपर string/ boolean)। यह साधन ==कभी भी रूपांतरित नहीं होगा undefinedया nullभले ही वे ग्रे बॉक्स में हों। ( undefinedया तो या nullदोनों के किसी भी संयोजन के लिए , ==हमेशा लौटेगा true। इसके अलावा, चाहे बाईं तरफ या दाईं ओर का मान मायने नहीं रखता, ==(और ===) एक ही परिणाम

— लौटाएगा

Answer 13

जावास्क्रिप्ट === बनाम == ।

0==false   // true
0===false  // false, because they are of a different type
1=="1"     // true, auto type coercion
1==="1"    // false, because they are of a different type

Answer 14

इसका अर्थ है बिना किसी प्रकार के सामंजस्य के प्रकार समानता का अर्थ है कि जावास्क्रिप्ट स्वचालित रूप से किसी अन्य डेटा प्रकार को स्ट्रिंग डेटा प्रकारों में परिवर्तित नहीं करता है

0==false   // true,although they are different types

0===false  // false,as they are different types

2=='2'    //true,different types,one is string and another is integer but 
            javaScript convert 2 to string by using == operator 

2==='2'  //false because by using === operator ,javaScript do not convert 
           integer to string 

2===2   //true because both have same value and same types 

Answer 15

एक विशिष्ट स्क्रिप्ट में कोई प्रदर्शन अंतर नहीं होगा। अधिक महत्वपूर्ण तथ्य यह हो सकता है कि हजार "===" हजार केबी से 1 केबी भारी है "==" ":) प्रोफाइल प्रोफाइलर आपको बता सकते हैं कि आपके मामले में कोई प्रदर्शन अंतर है या नहीं।

लेकिन व्यक्तिगत रूप से मैं वही करूंगा जो जेएसएलआईएनटी सुझाता है। यह सिफारिश प्रदर्शन के मुद्दों के कारण नहीं है, बल्कि इसलिए कि टाइप कॉर्शन का मतलब ('\t\r\n' == 0)सच है।

Comments

हमेशा सच नहीं। गज़िप संपीड़न के साथ, अंतर लगभग नगण्य होगा।

— डैनियल एक्स मूर

सहमत हैं, लेकिन हजार "===" का मतलब 10 हज़ार कोड लाइनें भी हैं इसलिए 1kb अधिक या कम ...;)

— जॉनी

f अपने आकार के बारे में चिंतित हैं, तो बस अपने सभी == को === के साथ स्वैप करें, फिर av eval में लिपटे एक regexp का उपयोग करें इसे वापस स्विच करने के लिए

Answer 16

बराबर तुलना ऑपरेटर == भ्रामक है और इससे बचा जाना चाहिए।

आप तो करना है इसके साथ रहते हैं, उसके बाद निम्न 3 चीजें याद रखें:

1. यह सकर्मक नहीं है: (a == b) और (b == c) से (a == c) नहीं होता है
2. यह अपनी उपेक्षा के लिए विशेष रूप से अनन्य है: (ए = बी) और (ए! = बी) हमेशा बूलियन मूल्यों के विपरीत होता है, सभी ए और बी के साथ।
3. संदेह के मामले में, निम्न सत्य तालिका को हृदय से जानें:

ज्वालामुखी में इक्कीसवीं चौकीदार

• तालिका में प्रत्येक पंक्ति 3 पारस्परिक रूप से "समान" मानों का एक सेट है, जिसका अर्थ है कि उनमें से कोई भी 2 मान समान हैं == *

** अंश: ध्यान दें कि पहले कॉलम पर कोई भी दो मान उस अर्थ में समान नहीं हैं। **

''       == 0 == false   // Any two values among these 3 ones are equal with the == operator
'0'      == 0 == false   // Also a set of 3 equal values, note that only 0 and false are repeated
'\t'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\r'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\n'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\t\r\n' == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

null == undefined  // These two "default" values are not-equal to any of the listed values above
NaN                // NaN is not equal to any thing, even to itself.

Answer 17

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

Answer 18

हाँ! कोई फर्क नहीं पड़ता।

===जावास्क्रिप्ट में ऑपरेटर मूल्य के साथ-साथ उस प्रकार की== जांच करता है जहां ऑपरेटर केवल मूल्य की जांच करता है (यदि आवश्यक हो तो प्रकार रूपांतरण करता है) ।

आप इसे आसानी से परख सकते हैं। एक HTML फ़ाइल में निम्नलिखित कोड पेस्ट करें और इसे ब्राउज़र में खोलें

<script>

function onPageLoad()
{
    var x = "5";
    var y = 5;
    alert(x === 5);
};

</script>

</head>

<body onload='onPageLoad();'>

आपको अलर्ट में ' गलत ' मिलेगा । अब आपके द्वारा संशोधित onPageLoad()विधि सहीalert(x == 5); हो जाएगी ।

Answer 19

=== ऑपरेटर मूल्यों और साथ ही समानता के लिए चर के प्रकारों की जांच करता है।

== ऑपरेटर सिर्फ समानता के लिए चर के मूल्य की जांच करता है।

Answer 20

यह एक सख्त जाँच परीक्षा है।

यह विशेष रूप से अच्छी बात है अगर आप 0 और झूठे और अशक्त के बीच की जाँच कर रहे हैं।

उदाहरण के लिए, यदि आपके पास:

$a = 0;

फिर:

$a==0; 
$a==NULL;
$a==false;

सभी सही हैं और आप यह नहीं चाहते हैं। मान लीजिए कि आपके पास एक फ़ंक्शन है जो किसी सरणी के 0 वें सूचकांक को वापस कर सकता है या विफलता पर गलत हो सकता है। यदि आप "==" झूठ के साथ जांच करते हैं, तो आप एक भ्रमित परिणाम प्राप्त कर सकते हैं।

तो ऊपर के रूप में एक ही बात के साथ, लेकिन एक सख्त परीक्षण:

$a = 0;

$a===0; // returns true
$a===NULL; // returns false
$a===false; // returns false

Comments

जावास्क्रिप्ट में, यह पूरी तरह से गलत और गलत रूप से अपूर्ण है। 0 != null। -1

— Ry-

Answer 21

JSLint कभी-कभी आपको सामान को संशोधित करने के लिए अवास्तविक कारण देता है। ===ठीक उसी तरह का प्रदर्शन है जैसे ==कि प्रकार पहले से ही हैं।

यह केवल तभी तेज होता है जब प्रकार समान नहीं होते हैं, जिस स्थिति में यह प्रकारों को परिवर्तित करने का प्रयास नहीं करता है लेकिन सीधे एक गलत रिटर्न देता है।

तो, IMHO, JSLint शायद नया कोड लिखता था, लेकिन बेकार-अनुकूलन को हर कीमत पर टाला जाना चाहिए।

मतलब, वहाँ बदलने के लिए कोई कारण नहीं है ==करने के लिए ===की तरह एक जांच में if (a == 'test')जब आप एक तथ्य यह है कि एक ही एक स्ट्रिंग हो सकता है के लिए जानते हैं।

बहुत सारे कोड को संशोधित करना जो डेवलपर्स के समय और समीक्षकों के समय को बर्बाद करता है और कुछ भी प्राप्त नहीं करता है।

Answer 22

केवल

==के साथ ऑपरेंड के बीच तुलना का मतलब है type conversion

और

===बिना ऑपरेंड के बीच तुलना का मतलब है type conversion

JavaScript में टाइप कन्वर्जन का मतलब javaScript अपने आप ही किसी भी दूसरे डेटा टाइप को स्ट्रिंग डेटा टाइप में बदल देता है।

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

123=='123'   //will return true, because JS convert integer 123 to string '123'
             //as we used '==' operator 

123==='123' //will return false, because JS do not convert integer 123 to string 
            //'123' as we used '===' operator 

Answer 23

एक सरल उदाहरण है

2 == '2'  -> true, values are SAME because of type conversion.

2 === '2'  -> false, values are NOT SAME because of no type conversion.

Answer 24

दोनों शीर्ष 2 उत्तर == का मतलब समानता और === का मतलब पहचान है। दुर्भाग्य से, यह कथन गलत है।

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

var a = [1, 2, 3];  
var b = [1, 2, 3];  
console.log(a == b)  // false  
console.log(a === b) // false  

उपरोक्त कोड में, दोनों == और === झूठे हो जाते हैं क्योंकि ए और बी एक ही वस्तु नहीं हैं।

कहने का तात्पर्य है: यदि दोनों का = = दोनों ही ऑब्जेक्ट हैं, तो == समान व्यवहार करता है ===, जिसका अर्थ पहचान भी है। इस दो ऑपरेटरों का आवश्यक अंतर प्रकार रूपांतरण के बारे में है। == इसमें समानता की जांच करने से पहले रूपांतरण है, लेकिन === नहीं करता है।

Answer 25

अंगूठे के एक नियम के रूप में, मैं आमतौर पर (और के बजाय ) ===का उपयोग करता हूं ।==!==!=

ऊपर दिए गए उत्तरों में कारण बताए गए हैं और डगलस क्रॉकफोर्ड भी इसके बारे में बहुत स्पष्ट है ( जावास्क्रिप्ट: द गुड पार्ट्स )।

हालांकि एक एकल अपवाद है : == null'शून्य या अपरिभाषित' के लिए जाँच करने का एक कुशल तरीका है:)

if( value == null ){
    // value is either null or undefined
}

उदाहरण के लिए jQuery 1.9.1 इस पैटर्न का 43 बार उपयोग करता है, और JSHint सिंटैक्स चेकर भी eqnullइस कारण के लिए आराम विकल्प प्रदान करता है ।

से jQuery शैली गाइड :

सख्त समानता जांच (===) का उपयोग == के पक्ष में किया जाना चाहिए। एकमात्र अपवाद तब होता है जब अशक्त और अशक्त अशक्त के लिए जाँच कर रहा है।

// Check for both undefined and null values, for some important reason. 
undefOrNull == null;

Answer 26

समस्या यह है कि आप आसानी से मुसीबत में पड़ सकते हैं क्योंकि जावास्क्रिप्ट में बहुत सारे निहितार्थ अर्थ हैं ...

var x = 0;
var isTrue = x == null;
var isFalse = x === null;

जो बहुत जल्द एक समस्या बन जाती है। क्यों अंतर्निहित रूपांतरण का सबसे अच्छा नमूना "बुराई" MFC / C ++ में इस कोड से लिया जा सकता है, जो वास्तव में CString से HANDLE में एक अंतर्निहित रूपांतरण के कारण संकलित होगा जो कि एक पॉइंटर टाइपडिफ प्रकार है ...

CString x;
delete x;

जो स्पष्ट रूप से रनटाइम के दौरान बहुत अपरिभाषित चीजें करता है ...

Google C ++ और STL में निहित रूपांतरणों के लिए इसके खिलाफ कुछ तर्क प्राप्त करने के लिए ...

Comments

0 == nullगलत है।

— गैरेट

Answer 27

से कोर जावास्क्रिप्ट संदर्भ

===trueयदि किसी प्रकार के रूपांतरण के साथ ऑपरेंड्स समान रूप से (ऊपर देखें) के बराबर हैं, तो लौटाता है ।

Answer 28

समानता तुलना:

ऑपरेटर ==

सही है, जब दोनों ऑपरेंड समान हैं। तुलना करने से पहले ऑपरेंड को उसी प्रकार में बदल दिया जाता है।

>>> 1 == 1
true
>>> 1 == 2
false
>>> 1 == '1'
true

समानता और प्रकार की तुलना:

ऑपरेटर ===

यदि दोनों ऑपरेंड समान और एक ही प्रकार के हैं, तो यह सही है। यदि आप इस तरह की तुलना करते हैं, तो यह आम तौर पर बेहतर और सुरक्षित है, क्योंकि कोई पीछे-पीछे चलने वाले प्रकार के रूपांतरण नहीं हैं।

>>> 1 === '1'
false
>>> 1 === 1
true

Answer 29

यहाँ एक आसान तुलना तालिका वाले रूपांतरण होती हैं और अंतर बताती है ==और ===।

जैसा कि निष्कर्ष बताता है:

"तीन बराबरी का उपयोग करें जब तक आप दो-बराबर के लिए होने वाले रूपांतरणों को पूरी तरह से नहीं समझते हैं।"

http://dorey.github.io/JavaScript-Equality-Table/

Answer 30

अशक्त और अपरिभाषित कुछ भी नहीं है, अर्थात

var a;
var b = null;

यहाँ aऔर bमान नहीं है। जबकि, 0, असत्य और '' सभी मूल्य हैं। इन सभी में एक बात समान है कि वे सभी मिथ्या मूल्य हैं, जिसका अर्थ है कि वे सभी मिथ्या शर्तों को पूरा करते हैं।

तो, 0, असत्य और '' मिलकर एक उप-समूह बनाते हैं। और दूसरी ओर, अशक्त और अपरिभाषित दूसरा उप-समूह बनाते हैं। नीचे की छवि में तुलना की जाँच करें। अशक्त और अपरिभाषित बराबर होगा। अन्य तीन एक दूसरे के बराबर होंगे। लेकिन, उन सभी को जावास्क्रिप्ट में झूठी शर्तों के रूप में माना जाता है।

यह किसी भी वस्तु (जैसे {}, सरणियों, आदि) के समान है, गैर-रिक्त स्ट्रिंग और बूलियन सत्य सभी सत्य परिस्थितियां हैं। लेकिन, वे सभी समान नहीं हैं।