जावास्क्रिप्ट नुकसान

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

प्रकार

जैसा कि ECMAScript विनिर्देश में लिखा गया है , कुल 6 प्रकार हैं:

1. अपरिभाषित
2. अशक्त
3. बूलियन
4. तार
5. संख्या
6. वस्तु

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

typeof 5; //"number", ,    typeof "hello"; //"string" typeof true; //"boolean" typeof undefined; //"undefined" typeof {}; //"object".  5  5 typeof null; //"object". WTF? typeof function(){}; //"function".      function? 

समस्या: नल का प्रकार अशक्त होने पर भी, ऑपरेटर 'ऑब्जेक्ट' लौटाता है; और फ़ंक्शन का प्रकार ऑब्जेक्ट है, ऑपरेटर 'फ़ंक्शन' लौटाता है, लेकिन ऐसा कोई प्रकार नहीं है।
स्पष्टीकरण: टाइपोफ़ एक प्रकार वापस नहीं करता है, लेकिन एक स्ट्रिंग जो तर्क पर निर्भर करता है और एक प्रकार का नाम नहीं है।
युक्ति: प्रकारों के बारे में भूल जाओ। गंभीरता से, मेरा मानना ​​है कि जेएस के 6 प्रकारों को जानने से आपको कोई फायदा नहीं होगा, और टाइपो ऑपरेटर का उपयोग अक्सर किया जाता है, इसलिए इसके काम के परिणामों को याद रखना बेहतर है:

तर्क प्रकार	परिणाम
अपरिभाषित	अपरिभाषित
अशक्त	वस्तु
बूलियन	बूलियन
संख्या	संख्या
तार	तार
ऑब्जेक्ट (नए ऑपरेटर के परिणाम, इनलाइन ऑब्जेक्ट ({कुंजी: मान}))	वस्तु
वस्तु (कार्य)	समारोह

मैजिक वैल्यू: अपरिभाषित, अशक्त, NaN

विनिर्देशों को निम्नानुसार वर्णित किया गया है:

• अपरिभाषित मूल्य - जब एक चर को एक मान नहीं सौंपा गया है तो आदिम मूल्य का उपयोग किया जाता है
• अपरिभाषित प्रकार - जिसका एकमात्र मान अपरिभाषित मान है
• अशक्त मूल्य - आदिम मूल्य जो किसी भी वस्तु मूल्य के जानबूझकर अनुपस्थिति का प्रतिनिधित्व करता है
• अशक्त प्रकार - जिसका एकमात्र मान शून्य मान है
• NaN - संख्या मान जो IEEE 754 "Not-a-Number" मान है

मेरे सिर में मैं निम्नलिखित रखता हूँ:

• अपरिभाषित - एक वैरिएबल का मूल्य जो आरंभीकृत नहीं किया गया है। अपरिभाषित प्रकार का एकमात्र मूल्य।
• अशक्त - जानबूझकर बनाई गई "खाली" वस्तु। प्रकार नल का एकमात्र मूल्य।
• NaN "नंबरों", "अनिश्चितता" को व्यक्त करने के लिए टाइप नंबर का एक विशेष मूल्य है। इसे प्राप्त किया जा सकता है, उदाहरण के लिए, 0 को 0 से विभाजित करने के परिणामस्वरूप (विश्लेषण के दौरान हमें याद है कि यह अनिश्चितता है, और 0 से अन्य संख्याओं को विभाजित करना अनंत है, जिसके लिए जेएस के पास इन्फिनिटी मूल्य हैं)।

इन अर्थों के साथ, मैंने "जादू" की बहुत खोज की। शुरुआत के लिए, उनके साथ बूलियन ऑपरेशन:

  !!undefined; //false !!NaN; //false !!null; //false // ,  3     boolean  false null == undefined; //true undefined === undefined; //true null === null; //true NaN == undefined; //false NaN == null; //false NaN === NaN; //false! NaN == NaN; //false! 

समस्या: कोई फर्क नहीं पड़ता कि हम NaN की तुलना करते हैं, तुलना का परिणाम हमेशा गलत होगा।
स्पष्टीकरण: NaN कई परिचालनों के परिणामस्वरूप हो सकता है: 0/0, parseInt ('स्ट्रिंग इर्रेड्यूबल टू नंबर'), Math.sqrt (-1) और यह अजीब होगा यदि -1 की जड़ 0/0 थी। इसीलिए NaN! == NaN
टिप: NaN के साथ बूलियन ऑपरेटरों का उपयोग न करें। जाँच करने के लिए, आपको isNaN फ़ंक्शन का उपयोग करने की आवश्यकता है।

  typeof a; //'undefined' a; //ReferenceError: a is not defined 

समस्या: टाइपऑफ़ ऑपरेटर हमें बताता है कि अघोषित चर का प्रकार अपरिभाषित है, लेकिन इसे एक्सेस करते समय एक त्रुटि उत्पन्न होती है।
स्पष्टीकरण: वास्तव में, 2 अवधारणाएं हैं - अनिर्धारित और अघोषित। तो, एक अघोषित चर एक अघोषित चर है और इसे एक्सेस करने से त्रुटि होती है। एक घोषित लेकिन आरंभिक चर नहीं मान अपरिभाषित लेता है और इसे एक्सेस करते समय कोई त्रुटि नहीं होती है।
युक्ति: किसी चर को एक्सेस करने से पहले, आपको यह सुनिश्चित करना चाहिए कि यह घोषित है। यदि आप अघोषित चर का उपयोग करते हैं, तो कॉल के बाद वाला कोड निष्पादित नहीं किया जाएगा।

  var a; //  ,     ,   undefined console.log(undefined); //undefined console.log(a); // undefined a === undefined; //true undefined = 1; console.log(undefined); //1 a === undefined; //false 

समस्या: किसी भी समय, हम अपरिभाषित मान को पढ़ और लिख सकते हैं, इसलिए, कोई इसे हमारे लिए अधिलेखित कर सकता है और अपरिभाषित के साथ तुलना करना गलत होगा।
स्पष्टीकरण: अपरिभाषित न केवल अपरिभाषित प्रकार का अपरिभाषित मूल्य है, बल्कि एक वैश्विक चर भी है, जिसका अर्थ है कि कोई भी इसे ओवरराइड कर सकता है।
युक्ति: अपरिभाषित के साथ बस चर की तुलना करना एक बुरा विचार है। इस समस्या को हल करने के लिए "बुलेटप्रूफ" कोड बनाने के लिए 3 विकल्प हैं।

• आप किसी चर के मूल्य की तुलना नहीं कर सकते हैं, लेकिन इसका प्रकार: "टाइप ए === 'अपरिभाषित"।
• तुरंत-इनवॉक्ड फ़ंक्शन पैटर्न का उपयोग करें:

  (function(window, undefined){ //..     ,   undefined  «». }(this)); 

• वास्तविक "अपरिभाषित" मान प्राप्त करने के लिए, आप शून्य ऑपरेटर का उपयोग कर सकते हैं (वैसे, मुझे इस ऑपरेटर के लिए कोई अन्य उपयोग नहीं पता है):

  typeof void(0) === 'undefined' // true 

अब अशक्त के साथ भी ऐसा ही करने का प्रयास करें:

  console.log(null); //null null = 1; //ReferenceError: Invalid left-hand side in assignment 

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



और अब NaN के साथ भी ऐसा ही करते हैं:

  console.log(NaN); //NaN NaN = 1; console.log(NaN); //NaN isNaN(NaN); //true 

समस्या: अपरिभाषित को पुनर्परिभाषित करते समय, सब कुछ ठीक हो जाता है, जब अशक्तता को पुनर्परिभाषित करते हैं, और जब NaN को पुनर्परिभाषित करते हैं, तो ऑपरेशन त्रुटि का कारण नहीं बनता है, लेकिन संपत्ति को फिर से परिभाषित नहीं किया गया था।
स्पष्टीकरण: आपको यह समझने की आवश्यकता है कि NaN एक वैश्विक संदर्भ चर (विंडो ऑब्जेक्ट) है। इसके अलावा, NaN को Number.NaN के माध्यम से "पहुंच" किया जा सकता है। लेकिन इससे कोई फर्क नहीं पड़ता है, आप इनमें से किसी भी संपत्ति को फिर से परिभाषित नहीं कर सकते हैं, क्योंकि NaN संपत्ति नहीं है:

  Object.getOwnPropertyDescriptor(window, NaN).writable; //false Object.getOwnPropertyDescriptor(Number, NaN).writable; //false 

युक्ति: JS प्रोग्रामर के रूप में, आपको संपत्ति विशेषताओं के बारे में जानना होगा:

गुण	टाइप	अर्थ
गणनीय	बूलियन	यदि सही है, तो यह संपत्ति फॉर-इन लूप में भाग लेगी।
लिखने योग्य	बूलियन	यदि गलत है, तो इस संपत्ति का मूल्य नहीं बदला जा सकता है।
विन्यास	बूलियन	यदि गलत है, तो इस संपत्ति का मूल्य नहीं बदला जा सकता है; संपत्ति विशेषताओं को हटाया या बदला नहीं जा सकता है
मूल्य	कोई	इसे पढ़ते समय संपत्ति का मूल्य
प्राप्त	ऑब्जेक्ट (या अपरिभाषित)	समारोह
सेट	ऑब्जेक्ट (या अपरिभाषित)	सेटर फंक्शन

आप Object.defineProperty विधि का उपयोग करके आपके द्वारा बनाई गई वस्तुओं के लिए गैर-हटाने योग्य या केवल-पढ़ने के लिए गुण घोषित कर सकते हैं:

  var obj = {}; Object.defineProperty(obj, 'a', {writable: true, configurable: true, value: 'a'}); Object.defineProperty(obj, 'b', {writable: false, configurable: true, value: 'b'}); Object.defineProperty(obj, 'c', {writable: false, configurable: false, value: 'c'}); console.log(obj.a); //a obj.a = 'b'; console.log(obj.a); //b delete obj.a; //true console.log(obj.b); //b obj.b = 'a'; console.log(obj.b); //b delete obj.b; //true console.log(obj.c); //c obj.b = 'a'; console.log(obj.c); //c delete obj.b; //false 

भिन्नात्मक संख्याओं के साथ कार्य करना

आइए 3rd ग्रेड को याद करें और कुछ दशमलव अंश जोड़ें। जेएस कंसोल में मन में जोड़ के परिणामों की जाँच करें:

  0.5 + 0.5; //1 0.5 + 0.7; //1.2 0.1 + 0.2; //0.30000000000000004; 0.1 + 0.7; //0.7999999999999999; 0.1 + 0.2 - 0.2; //0.10000000000000003 

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

  function sum() { var result = 0; for (var i = 0, max = arguments.length; i< max; i++ ) { result += arguments[i]*10; } return result / 10; } sum(0.5, 0.5); //1 sum(0.5, 0.7); //1.2 sum(0.1, 0.2); //0.3 sum(0.1, 0.7); //0.8 sum(0.1, 0.2, -0.2); //0.1 

निष्कर्ष

अप्रत्याशित परिणामों के साथ ये कुछ असामान्य उदाहरण हैं। यदि आप उन्हें याद करते हैं, तो यह उसी रेक पर कदम नहीं बढ़ाता है और जल्दी से समझ जाता है कि समस्या क्या है। यदि आपको कोड का एक नया "अतार्किक" टुकड़ा मिलता है, तो यह समझने की कोशिश करें कि विनिर्देश या एमडीएन को पढ़कर भाषा के संदर्भ में क्या हो रहा है।