javascript हरण कौन सा ऑपरेटर बराबर है(== बनाम===) जावास्क्रिप्ट तुलना में इस्तेमाल किया जाना चाहिए?




हिंदी में जावास्क्रिप्ट परिचय (20)

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

https://code.i-harness.com

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

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

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

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


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


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

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


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

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

पहचान ( === ) ऑपरेटर समानता ( == ) ऑपरेटर के समान व्यवहार करता है, सिवाय इसके कि कोई प्रकार का रूपांतरण नहीं किया जाता है, और प्रकार बराबर माना जाना चाहिए।

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

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

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

जावास्क्रिप्ट में समानता ऑपरेटरों के दो सेट हैं: === और !== , और उनके बुरे जुड़वां == और != । अच्छे लोग जिस तरह से आप उम्मीद करेंगे काम करते हैं। यदि दो ऑपरेंड एक ही प्रकार के हैं और एक ही मान हैं, तो === true उत्पन्न करता true और !== false पैदा करता 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 के answer में एक अच्छा बिंदु लाया गया था। संदर्भ प्रकारों के लिए == और === लगातार एक दूसरे के साथ कार्य करें (एक विशेष मामले को छोड़कर)।

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 कन्स्ट्रक्टर द्वारा बनाई गई स्ट्रिंग ऑब्जेक्ट के साथ स्ट्रिंग String की तुलना पर विचार करें।

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

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

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


मुझे यह सलाह जोड़ने दो:

यदि संदेह में, specification पढ़ें!

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

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

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

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

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

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

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

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

एडियाकापी ने नीचे एक टिप्पणी में लिखा:

विनिर्देश से

11.2.2 नया ऑपरेटर :

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

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

स्ट्रिंग कन्स्ट्रक्टर के लिए भी नया हमेशा ऑब्जेक्ट देता है। और हां! तारों के लिए मूल्य अर्थशास्त्र (चरण 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

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

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

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)

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


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

ऑपरेटर ==

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

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

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

ऑपरेटर ===

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

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

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

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

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

दूसरी तरफ, पहचान ऑपरेटर === टाइप जबरन नहीं करता है, और इस प्रकार तुलना करते समय मूल्यों को परिवर्तित नहीं करता है।


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

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


बराबर तुलना ऑपरेटर == उलझन में है और इससे बचा जाना चाहिए।

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

  1. यह संक्रमणीय नहीं है: (ए == बी) और (बी == सी) का नेतृत्व नहीं करता है (ए == सी)
  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.

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

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

true

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

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

'0' == false // true

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

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

फिर तारों के साथ weirder

[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();
}

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

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

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

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

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

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

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

समाप्त।


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

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

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

<script>

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

</script>

</head>

<body onload='onPageLoad();'>

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


केवल

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

और

===मतलब ऑपरेटरों के बीच तुलना के बिना तुलना type conversion

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

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

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 

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

यह एक अच्छी बात है, खासकर यदि आप 0 और झूठी और शून्य के बीच जांच कर रहे हैं।

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

$a = 0;

फिर:

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

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

तो ऊपर की तरह एक ही चीज़ के साथ, लेकिन एक सख्त परीक्षण:

$a = 0;

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

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

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

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

CString x;
delete x;

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

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


* ऑपरेटर === बनाम == *

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

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

यह केवल तेज़ होता है जब प्रकार समान नहीं होते हैं, इस स्थिति में यह प्रकारों को बदलने की कोशिश नहीं करता है लेकिन सीधे झूठा लौटाता है।

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

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

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


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

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

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

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

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





identity-operator