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




operators equality equality-operator identity-operator (25)

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

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

var1 === var2

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

var1 == var2

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

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

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

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

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

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

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


यह जांचता है कि क्या एक ही पक्ष प्रकार के साथ-साथ मूल्य के बराबर है।

उदाहरण:

'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


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

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

हालांकि एक भी अपवाद है : == 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;

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

यदि आपको इसके साथ रहना है, तो निम्नलिखित 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.

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

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

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

<script>

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

</script>

</head>

<body onload='onPageLoad();'>

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


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

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

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

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

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

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


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

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

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

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

ऑपरेटर ==

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

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

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

ऑपरेटर ===

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

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

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

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

किसी भी आवश्यक प्रकार के रूपांतरण करने के बाद == ऑपरेटर समानता के लिए तुलना करेगा। === ऑपरेटर रूपांतरण नहीं करेगा, इसलिए यदि दो मान समान प्रकार नहीं हैं === 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


जावास्क्रिप्ट में इसका मतलब वही मान और प्रकार है।

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

4 == "4" // will return true

परंतु

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

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

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

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 कन्स्ट्रक्टर का उपयोग करके एक स्ट्रिंग ऑब्जेक्ट बनाना कुछ ऑब्जेक्ट बनाता है जो अधिकांश समय स्ट्रिंग के रूप में व्यवहार करता है।


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

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

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

$a = 0;

फिर:

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

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

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

$a = 0;

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

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

यदि संदेह में, 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 देखें) खो गया है।

और इसका अंततः मतलब है: नया स्ट्रिंग ("ए")! == "ए"


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

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


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

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

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

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

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


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


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

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 से अधिक पुनरावृत्तियों, याद है) नगण्य है। प्रदर्शन करने का कोई कारण नहीं है === । सुरक्षा टाइप करें (अच्छी तरह से, जैसा कि आप जावास्क्रिप्ट में प्राप्त करने जा रहे हैं), और कोड की गुणवत्ता है।


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

var a;
var b = null;

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

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

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


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

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

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


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

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

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

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

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


=== ऑपरेटर को सख्त तुलना ऑपरेटर कहा जाता है, यह == ऑपरेटर से भिन्न होता है।

आइए 2 वर्र्स ए और बी लें।

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

"ए === बी" ए और बी के मामले में वही मान होना चाहिए और इसके लिए एक ही प्रकार का सत्य होना चाहिए।

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

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% उपयोग परिदृश्य में इससे कोई फर्क नहीं पड़ता कि आप किस का उपयोग करते हैं, लेकिन जब आप एक दिन में कुछ अप्रत्याशित व्यवहार करते हैं तो अंतर जानने में आसान होता है।


मैं javascript:void(0) उपयोग करता हूं javascript:void(0)

तीन कारण डेवलपर्स की एक टीम के बीच # के उपयोग को प्रोत्साहित करने के लिए अनिवार्य रूप से कुछ इस तरह के फ़ंक्शन के रिटर्न वैल्यू का उपयोग करते हैं:

function doSomething() {
    //Some code
    return false;
}

लेकिन फिर वे ऑनक्लिक में return doSomething() का उपयोग करना भूल जाते हैं और बस doSomething() उपयोग करें।

# से बचने का दूसरा कारण यह है कि अंतिम return false; अगर कॉल किया गया फ़ंक्शन किसी त्रुटि को फेंक देता है तो निष्पादित नहीं होगा। इसलिए डेवलपर्स को बुलाए गए फ़ंक्शन में उचित रूप से किसी भी त्रुटि को संभालना याद रखना होगा।

एक तीसरा कारण यह है कि ऐसे मामले हैं जहां onclick घटना संपत्ति गतिशील रूप से असाइन की जाती है। मैं विशेष रूप से अनुलग्नक या किसी अन्य विधि के लिए फ़ंक्शन को कोड किए बिना किसी फ़ंक्शन को कॉल करने या इसे गतिशील रूप से असाइन करने में सक्षम होना पसंद करता हूं। इसलिए एचटीएमएल मार्कअप में मेरा onclick (या कुछ भी) इस तरह दिखता है:

onclick="someFunc.call(this)"

या

onclick="someFunc.apply(this, arguments)"

javascript:void(0) का उपयोग करना javascript:void(0) उपरोक्त सभी सिरदर्द से बचाता है, और मुझे डाउनसाइड के कोई उदाहरण नहीं मिला है।

तो यदि आप एकमात्र डेवलपर हैं तो आप स्पष्ट रूप से अपनी पसंद कर सकते हैं, लेकिन यदि आप एक टीम के रूप में काम करते हैं तो आपको या तो राज्य करना होगा:

href="#" प्रयोग करें, सुनिश्चित करें कि onclick हमेशा return false; अंत में, किसी भी बुलाए गए फ़ंक्शन में कोई त्रुटि नहीं आती है और यदि आप onclick संपत्ति के लिए गतिशील रूप से फ़ंक्शन संलग्न करते हैं तो सुनिश्चित करें कि साथ ही कोई त्रुटि फेंकने से यह false नहीं आती false

या

href="javascript:void(0)"

दूसरा संवाद करने के लिए स्पष्ट रूप से बहुत आसान है।





javascript operators equality equality-operator identity-operator