डबल बराबर (==) और ट्रिपल बराबर के बीच जावास्क्रिप्ट प्रदर्शन अंतर (===)

Question

जावास्क्रिप्ट में, एक डबल बराबर (==) बनाम एक ट्रिपल बराबर (===) का उपयोग कर बनाम प्रदर्शन अंतर है?

उदाहरण: if (foo == bar) बनाम if (foo === bar)

Answer 1

सख्त तुलना (===) की तुलना में अधिक बातों की जांच करने के लिए हमेशा थोड़ा तेज है, लेकिन the difference is usually negligible हो जाएगा है।

यदि आप निश्चित रूप से जानते हैं कि आपको तुलना में टाइप जबरन की आवश्यकता नहीं है तो यह निश्चित रूप से === को प्राथमिकता देने के लिए समझ में आता है। यह हमेशा कम से कम == जितना तेज़ होगा।

Answer 2

प्रदर्शन के कारण

, मुझे लगता है कि ===, बेहतर प्रदर्शन किया है क्योंकि ===== तुलना में अधिक कड़ाई है,

उदा क्रोम कंसोल में निम्न का प्रयास करें।

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

=====

Answer 3

कुछ flimsy परीक्षणों से, ===== से थोड़ा तेज़ प्रतीत होता है।

मामूली रूप से, मेरा मतलब है कि मैं कई लाख परीक्षणों के अंतराल पर कुछ मिलीसेकंड अंतर देख सकता हूं। काम के लिए जो भी सही है, उसका उपयोग करने के बजाय आपको प्रदर्शन लाभ की आवश्यकता नहीं हो सकती है।

संपादित करें: वास्तव में, आप/किस/आप तुलना कर रहे हैं और ब्राउज़र कार्यान्वयन पर निर्भर करते हैं। दूसरे शब्दों में, इसके बारे में चिंता न करें।

Answer 4

• प्रकार की तुलना में एक ही कर रहे हैं, वे समान हैं। यही कहना है कि वे सटीक उसी एल्गोरिदम का उपयोग करते हैं।

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

Answer 5

संपादित करें: यहां संदर्भ के लिए डॉ एक्सल Rauschmayer http://www.2ality.com/2011/06/javascript-equality.html सच महान लिखने अप द्वारा कल्पना स्पष्टीकरण द्वारा है।

=== (सख्त समानता): केवल वही मान समान मानते हैं जो समान प्रकार के होते हैं।

1. अपरिभाषित === अपरिभाषित, अशक्त === अशक्त,
2. NaN खुद सहित कुछ भी नहीं ===,
3. आदिम [संख्या | स्ट्रिंग | बूलियन] === आदिम मूल्य बराबर,
4. === केवल स्वयं (एक ही सटीक इकाई)

== (उदार समानता)

01 आत्म (+0 === -0)

दो वस्तुओं [| | वस्तु समारोह सरणी] को

1. यदि दोनों मानों का एक ही प्रकार है: === के साथ तुलना करें।
2. अपरिभाषित == बातिल
3. संख्या और स्ट्रिंग: स्ट्रिंग => संख्या और संख्या के लिए
4. बूलियन और गैर बूलियन => गैर बूलियन तुलना और
5. स्ट्रिंग या संख्या => एक वस्तु की तुलना: परिवर्तित वस्तु आदिम और तुलना करने के लिए।

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

यदि आप objOne == objTwo क्या वास्तव में होता है [[EQUALS]].call(objOne.valueOf(), objTwo.valueOf())

valueOf के संकल्प को कुछ हद तक शामिल किया जा सकता है, जे एस और आंतरिक इंजन सामान में उजागर कार्यों के बीच उछल है। यह कहने के लिए पर्याप्त है कि तुलना हमेशा प्राइमेटिव के लिए दो मूल्यों के साथ खत्म हो जाएगी या एक त्रुटि फेंक दी जाएगी।

संपादित करें:EQUALS वास्तव में STRICT_EQUALS पहले जो प्रक्रिया के बाकी preempts कोशिश करता है।

दिलचस्प बात यह है कि valueOf (और इसके साथी टूस्ट्रिंग) अतिसंवेदनशील हैं। क्रोम में कोड का यह टुकड़ा चलाएं (मुझे लगता है कि कोई वेबकिट, यह सुनिश्चित नहीं है कि जेएससी और वी 8 इस बोली को साझा करते हैं)। यह अपने mindpiece उड़ा देगा:

var actions = []; 
var overload = { 
    valueOf: function(){ 
    var caller = arguments.callee.caller; 
    actions.push({ 
     operation: caller.name, 
     left: caller.arguments[0] === this ? "unknown" : this, 
     right: caller.arguments[0] 
    }); 
    return Object.prototype.toString.call(this); 
    } 
}; 
overload.toString = overload.valueOf; 
overload == 10; 
overload === 10; 
overload * 10; 
10/overload; 
overload in window; 
-overload; 
+overload; 
overload < 5; 
overload > 5; 
[][overload]; 
overload == overload; 
console.log(actions); 

आउटपुट:

[ { operation: 'EQUALS', 
    left: overload, 
    right: 10 }, 
    { operation: 'MUL', 
    left: overload, 
    right: 10 }, 
    { operation: 'DIV', 
    left: 'unknown', 
    right: overload }, 
    { operation: 'IN', 
    left: overload, 
    right: DOMWindow }, 
    { operation: 'UNARY_MINUS', 
    left: overload, 
    right: undefined }, 
    { operation: 'TO_NUMBER', 
    left: overload, 
    right: undefined }, 
    { operation: 'COMPARE', 
    left: overload, 
    right: 5 }, 
    { operation: 'COMPARE', 
    left: 'unknown', 
    right: overload }, 
    { operation: 'ToString', 
    left: 'unknown', 
    right: overload } ] 

== और === के बीच अंतर का सार द्वारा === उस सूची में नहीं दिख रहा दर्शाया गया है। यह पूरी तरह से जावास्क्रिप्ट लैंड में यात्रा छोड़ देता है। प्रदर्शन की तुलना करते समय वह साहसिक महंगा है।

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

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