जावास्क्रिप्ट - === बनाम == ऑपरेटरों का प्रदर्शन

Question

कुछ हफ्ते पहले, मैंने में तुलना ऑपरेटर के बारे में इस धागे को Is < faster than <=? पढ़ा है। ऐसा कहा जाता था कि < और <= के बीच प्रदर्शन में कोई अंतर नहीं है क्योंकि उन्हें समान/समान मशीन कमांड के रूप में व्याख्या किया गया है।

उसी समय, हमारी कंपनी के "सर्वोत्तम प्रथाओं" में, यह कहा गया था कि हमें हमेशा "===" की बजाय चीजों की तुलना करने के लिए "===" का उपयोग करना चाहिए। इसलिए, मुझे आश्चर्य हुआ कि यह हमेशा उपयुक्त है क्योंकि मुझे "==" और "टाइपोफ़ ... ==" का उपयोग करने के लिए उपयोग किया जाता है और मैं अपना लेखन तरीका नहीं बदलना चाहता: -]

ध्यान दें कि यह जावास्क्रिप्ट के संदर्भ में है।

तो, मैं एक छोटे से अनुसंधान किया है और यहां Which equals operator (== vs ===) should be used in JavaScript comparisons? यह कहा जाता है कि:

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

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

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

Answer 1

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

ECMA standard से:

11.9.6 सख्त समानता तुलना एल्गोरिथ्म तुलना एक्स === y, जहां x और y मान होते हैं, सही या गलत पैदा करता है।

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

Answer 2

इससे कोई फर्क नहीं पड़ता कि आपको क्या प्रदर्शन मिलता है, === स्पष्ट रूप से इस मामले में बेहतर विकल्प है। बेहतर प्रदर्शन जैसे कुछ और सिर्फ केक पर टुकड़े करना है। इसके अलावा, अंतर किसी भी तरह से कम है।

Answer 3

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

=== का उपयोग करें जब तक कि आपके पास कोई शानदार कारण न हो (आप शायद नहीं)।

Answer 4

यह एक पटकथा भाषा है। इन ऑपरेटरों का प्रदर्शन इतना महत्वपूर्ण नहीं है कि आपको इसके बारे में चिंता करनी चाहिए, क्योंकि ऐसी चीजों का एक समूह है जो अधिक शक्ति का उपभोग करता है, जैसे कि यह वर्चुअल मशीन में चलता है, कमजोर टाइप किया जाता है, साथ काम करता है एक ब्राउज़र के अंदर एक HTML डोम ...

इसके अलावा, दोनों ऑपरेटरों काफी अलग चीजें करते हैं, इसलिए किसी भी मामले में किसी के साथ अंतर-परिवर्तनीय नहीं हो सकता है।

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

और यह भाग्यशाली है, क्योंकि ज्यादातर मामलों में === बेहतर विकल्प है।:)

लेकिन वैसे भी, आप आसानी से इसका परीक्षण कर सकते हैं (सुनिश्चित करें कि आप एक ही प्रकार और दो अलग-अलग प्रकार के साथ कई मामलों का परीक्षण करें), लेकिन अगर आपको यह नहीं पता कि इसका परीक्षण कैसे किया जाए, तो मैं रुकूंगा पूरी तरह से इसके बारे में चिंता करते हुए। अंतर, यदि कोई है, तो आपको मारने वाला नहीं है।

Answer 5

सबसे पहले, प्रदर्शन बस नहीं एक चिंता का विषय है। किसी भी वास्तविक लिपि के लिए, दूसरे पर एक ऑपरेटर का उपयोग करने का कोई भी प्रदर्शन लाभ कोड में अन्य बाधाओं की तुलना में infinitessimally छोटा होगा (आमतौर पर डीओएम मैनिपुलेशन नंबर एक लक्ष्य होगा)।

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

typeof के मामले में, अपने प्रश्न में उल्लेख किया है के रूप में, दो ऑपरेंड एक ही प्रकार (स्ट्रिंग) के होने की गारंटी कर रहे हैं और दोनों ऑपरेटरों ठीक एक ही बात करेंगे, इसलिए केवल कारणों पर एक ऑपरेटर के पक्ष में अन्य स्टाइलिस्ट हैं।

जेएस समुदाय पूरी तरह से इस पर कड़ी मेहनत कर चुका है: सर्वसम्मति "कभी भी == और != का उपयोग न करें जब तक आपको टाइप जबरदस्ती की आवश्यकता न हो", जो मेरे स्वाद के लिए बहुत ही विडंबनात्मक है।

Answer 6

मुझे आसानी से सत्यापित साक्ष्य के साथ एक उत्तर लगता है।

ये ऑपरेशन इतने छोटे हैं कि प्रदर्शन का प्रदर्शन करना मुश्किल है।

• == 1648 सच
• === 1629 सच
• नियंत्रण परीक्षण 1575 सच

आप नियंत्रण परीक्षण बंद घटाना है, तो ऐसा लगता है कि में एक ~ 30% अंतर नहीं है लग रहा है मेरे ब्राउज़र पर उनकी गति। यदि आप इसे कई बार करते हैं, तो आप अलग-अलग उत्तर प्राप्त कर सकते हैं, लेकिन === आमतौर पर सबसे तेज़ हो जाता है, जो मुझे लगता है कि अंतर कितना नगण्य है केवल यह एक प्रमाण है।

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

var testString = "42"; 
 
var testNumber = 42; 
 
var testObject = {}; 
 

 

 
var start = Date.now(); 
 
var result = null; 
 
for(var i = 0; i < 100000000; i++){ 
 
    result = testString == testString && testNumber == testNumber && testObject == testObject && 
 
    testString == testString && testNumber == testNumber && testObject == testObject && 
 
    testString == testString && testNumber == testNumber && testObject == testObject && 
 
    testString == testString && testNumber == testNumber && testObject == testObject && 
 
    testString == testString && testNumber == testNumber && testObject == testObject && 
 
    testString == testString && testNumber == testNumber && testObject == testObject && 
 
    testString == testString && testNumber == testNumber && testObject == testObject && 
 
    testString == testString && testNumber == testNumber && testObject == testObject && 
 
    testString == testString && testNumber == testNumber && testObject == testObject && 
 
    testString == testString && testNumber == testNumber && testObject == testObject && 
 
    testString == testString && testNumber == testNumber && testObject == testObject && 
 
    testString == testString && testNumber == testNumber && testObject == testObject && 
 
    testString == testString && testNumber == testNumber && testObject == testObject && 
 
    testString == testString && testNumber == testNumber && testObject == testObject && 
 
    testString == testString && testNumber == testNumber && testObject == testObject && 
 
    testString == testString && testNumber == testNumber && testObject == testObject && 
 
    testString == testString && testNumber == testNumber && testObject == testObject && 
 
    testString == testString && testNumber == testNumber && testObject == testObject && 
 
    testString == testString && testNumber == testNumber && testObject == testObject && 
 
    testString == testString && testNumber == testNumber && testObject == testObject 
 
} 
 

 
console.log("==", Date.now() - start, result); 
 

 
var start = Date.now(); 
 
var result = null; 
 
for(var i = 0; i < 100000000; i++){ 
 
    result = testString === testString && testNumber === testNumber && testObject === testObject && 
 
    testString === testString && testNumber === testNumber && testObject === testObject && 
 
    testString === testString && testNumber === testNumber && testObject === testObject && 
 
    testString === testString && testNumber === testNumber && testObject === testObject && 
 
    testString === testString && testNumber === testNumber && testObject === testObject && 
 
    testString === testString && testNumber === testNumber && testObject === testObject && 
 
    testString === testString && testNumber === testNumber && testObject === testObject && 
 
    testString === testString && testNumber === testNumber && testObject === testObject && 
 
    testString === testString && testNumber === testNumber && testObject === testObject && 
 
    testString === testString && testNumber === testNumber && testObject === testObject && 
 
    testString === testString && testNumber === testNumber && testObject === testObject && 
 
    testString === testString && testNumber === testNumber && testObject === testObject && 
 
    testString === testString && testNumber === testNumber && testObject === testObject && 
 
    testString === testString && testNumber === testNumber && testObject === testObject && 
 
    testString === testString && testNumber === testNumber && testObject === testObject && 
 
    testString === testString && testNumber === testNumber && testObject === testObject && 
 
    testString === testString && testNumber === testNumber && testObject === testObject && 
 
    testString === testString && testNumber === testNumber && testObject === testObject && 
 
    testString === testString && testNumber === testNumber && testObject === testObject && 
 
    testString === testString && testNumber === testNumber && testObject === testObject 
 
} 
 
console.log("===", Date.now() - start, result); 
 
var start = Date.now(); 
 
for(var i = 0; i < 100000000; i++){ 
 
    result = true && true && true && 
 
    true && true && true && 
 
    true && true && true && 
 
    true && true && true && 
 
    true && true && true && 
 
    true && true && true && 
 
    true && true && true && 
 
    true && true && true && 
 
    true && true && true && 
 
    true && true && true && 
 
    true && true && true && 
 
    true && true && true && 
 
    true && true && true && 
 
    true && true && true && 
 
    true && true && true && 
 
    true && true && true && 
 
    true && true && true && 
 
    true && true && true && 
 
    true && true && true && 
 
    true && true && true 
 
} 
 
console.log("control test", Date.now() - start, result);