🚰 📝 🦊 Brainfuckers जावास्क्रिप्ट डेवलपर्स के बीच देखा 🏂🏿 📌 😣

जावास्क्रिप्ट	पीएचपी
`// if ( 0 )`	`// if ( 0 )`
`if ( 2 )`	`if ( 2 )`
`if ( -1 )`	`if ( -1 )`
`if ( false == 0 )`	`if ( false == 0 )`
`if ( false == '0' )`	`if ( false == '0' )`
`if ( false == '00' )`	`// if ( false == '00' )`
`if ( false == '0x0' )`	`// if ( false == '0x0' )`
- हम देखते हैं कि जावास्क्रिप्ट एक स्ट्रिंग को एक संख्या के साथ और अधिक ध्यान से देखता है। हम और आगे बढ़ें
`if ( 'bla bla bla' )`	`if ( 'bla bla bla' )`
`// if ( false == null )`	`if ( false == null )`
- अद्भुत, लेकिन जावास्क्रिप्ट में झूठे शून्य नहीं है

`if ( false == !!null )`	`if ( false == !!null )`
- लेकिन अगर हमने दो बार शून्य से इनकार किया है - जावास्क्रिप्ट PHP की तरह व्यवहार करता है
`// if ( false == undefined )`	`if ( false == $undefined )`
- उफ़! अपरिभाषित जावास्क्रिप्ट में भी गलत नहीं है
`if ( false == !!undefined )`	`if ( false == !!$undefined )`
- दोहरा नकार चीजों को फिर से बदल देता है
`// if ( false == 'false' )`	`// if ( false == 'false' )`
`if ( true == 1 )`	`if ( true == 1 )`
`// if ( true == 11 )`	`if ( true == 11 )`
- एक अन्य विशेषता - PHP में, शून्य के अलावा कोई भी संख्या सत्य है। जेएस में, केवल एक
`if ( 11 )`	`if ( 11 )`
- लेकिन अगर हम संख्या को सीधे पास करते हैं यदि, तो दोनों भाषाओं में वह सब कुछ है जो नॉनजरो है
`// if ( true == '0' )`	`// if ( true == '0' )`
`if ( '0' )`	`// if ( '0' )`
- शायद जावास्क्रिप्ट और PHP के बीच सबसे कपटी अंतर। आगे
`// if ( true == 'true' )`	`if ( true == 'true' )`
- एक और महत्वपूर्ण अंतर - पीएचपी एक स्ट्रिंग को एक स्ट्रिंग में जोड़ता है, और जेएस एक स्ट्रिंग को एक स्ट्रिंग में डालता है
`// if ( true == -1 )`	`if ( true == -1 )`
- फिर से अंतर - जेएस सच में एक संख्या के लिए कम है (यह 1 निकलता है) और -1 के साथ तुलना की जाती है। और PHP -1 में इसे एक बोया में डाला जाता है (यह सच है)
`if ( 'bla bla bla' )`	`if ( 'bla bla bla' )`
`// if ( undefined )`	`// if ( $undefined )`
`if ( undefined == null )`	`if ( $undefined == null )`
`// if ( 1 == 2 )`	`// if ( 1 == 2 )`
`if ( 1 == '1' )`	`if ( 1 == '1' )`
`if ( 2 == '2' )`	`if ( 2 == '2' )`
`if ( 2 == '02' )`	`if ( 2 == '02' )`
`if ( 2 == '0x2' )`	`if ( 2 == '0x2' )`
`// if ( 2 == '0c2' )`	`// if ( 2 == '0c2' )`
`// if ( '-1' == true )`	`if ( '-1' == true )`
`// if ( '' )`	`// if ( '' )`
`// if ( NaN == NaN )`	`//`
- JS में एक ऐसा वेरिएबल भी है जो खुद के बराबर नहीं है! यह NaN है

क्या आपने कभी पूरे विश्वास के साथ जावास्क्रिप्ट में शर्तें लिखी हैं?

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

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

नहीं, जावास्क्रिप्ट निश्चित रूप से == ऑपरेटर के साथ तुलना में एक प्रकार कास्ट करता है, लेकिन यह हम जो उम्मीद करते हैं उसके विपरीत है। खासतौर पर हममें से जिन्होंने PHP में लिखा है।

यहाँ ऑपरेटर के लिए प्रलेखन से एक अंश है ==:

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

लेकिन यहाँ एक उदाहरण है:

 if( null == false ) //

ऑपरेंड में से एक बूलियन प्रकार है। यदि आप दस्तावेज़ को मानते हैं, तो दोनों ऑपरेंड को एक नंबर में बदलना होगा। नंबर (शून्य) 0 देगा और नंबर (गलत) शून्य देगा। शर्त को पूरा करना होगा, लेकिन ऐसा नहीं होता है। बस रचनाकारों ने फैसला किया - वह अशक्त एक विशेष अर्थ है? मेरे मुंह में पैर! नहीं, बल्कि उन्होंने इस तरह सोचा: अशक्त एक वस्तु प्रकार है। जावास्क्रिप्ट झूठी वस्तु प्रकार की ओर जाता है (यह अंदर एक गलत मूल्य के साथ कुछ बेवकूफ सरणी वस्तु को बदल देता है), और फिर यह इन दो वस्तुओं की तुलना करता है । और शायद ये दोनों ही मूल्य हैं

एक स्ट्रिंग में डाली जाती हैं, 'null' === 'false' प्राप्त करें? नहीं, वास्तव में:

यदि ऑपरेंड में से एक बुलियन है, तो यह 1 (यूनिट) में बदल जाता है, अगर यह सच है। और ० (शून्य) होने पर वह मिथ्या है।

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

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

अगला, हम झूठी के लिए एक शून्य के साथ लाइन की जांच करते हैं:

 if('0' == false) // ,    if('0') //      ! alert(String(false)); //   'false' alert(Boolean('0')); //  true

अजीब है, है ना? यदि If 0 ’गलत है, लेकिन अगर हम इसे सीधे यदि इस स्थिति में परीक्षण करते हैं, तो यह सच है। सब कुछ सरल है। जावास्क्रिप्ट के रचनाकारों ने फैसला किया कि यदि आप एक स्ट्रिंग को बुआ को देते हैं, तो इस स्ट्रिंग की लंबाई की जांच की जाएगी। यदि स्ट्रिंग की लंबाई शून्य से अधिक है, तो यह सच है। अगर स्ट्रिंग खाली है तो ही गलत होगा। और पहले मामले में, जब हम '0' == की जाँच करते हैं, न कि स्ट्रिंग बूलियन को डाली जाती है, बल्कि, झूठी को शून्य पर डाली जाती है और स्ट्रिंग '0' के साथ तुलना की जाती है।

संख्या के साथ एक ही बात - भले ही:

 if(true == 2) //   //  if(2) // . alert(Boolean(2)); //  true alert(Number(true)); //  1

क्यों? सब कुछ सरल है - जावा स्क्रिप्ट जब == ऑपरेटर के साथ तुलना करने पर सबसे पहले एकता (1) के लिए सच हो जाएगा, और फिर यह दो (2) से तुलना करेगा। बेशक वे समान नहीं हैं और शर्त पूरी नहीं होगी। जैसा कि हम देख सकते हैं, बुलियन ऑपरेशन में जावास्क्रिप्ट एक नंबर पर बुलेट को डालना पसंद करते हैं, और इसके विपरीत नहीं।

लेकिन व्यर्थ में, कम घटनाएं होंगी।

आसान निकास

सबसे आसान तरीका है, ऑपरेंड्स के सामने डबल नेगेटिव डालना !! । यह निश्चित रूप से बुलियन को किसी भी प्रकार का डालेगा। लेकिन हमें यह याद रखना चाहिए कि जावा स्क्रिप्ट में PHP के विपरीत, '0' सच होगा। क्योंकि बूलियन को कास्टिंग करते समय जावा स्क्रिप्ट स्ट्रिंग की लंबाई को मापता है, और PHP पहले स्ट्रिंग के संख्यात्मक मूल्य की गणना करता है, और फिर bule की ओर जाता है।

प्रोग्रामर्स के दिमाग को बख्श दें

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

नियमों के सभी अपवाद एक उपद्रव हैं। अपवाद समझ को कम करते हैं, असुविधा की भावना पैदा करते हैं। चलो समझने योग्य बातें करते हैं!

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

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

अन्यथा, यह जावास्क्रिप्ट में बदल जाएगा।

आपका ध्यान के लिए धन्यवाद, काश आपका जीवन अधिक समझ में आता, ओलेग जोज़िक।

पुनश्च

आप यहां अधिक दृश्य तुलना तालिका देख सकते हैं ।

मामूली विज्ञापन: मैं फाइल भेजने के लिए MicroMail का उपयोग करने की सलाह देता हूं

Brainfuckers जावास्क्रिप्ट डेवलपर्स के बीच देखा

आसान निकास

प्रोग्रामर्स के दिमाग को बख्श दें

More articles: