20 और 1 जावास्क्रिप्ट गैजेट जो मुझे अभी याद नहीं है

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

शुरू करने से पहले, मैं 3 बिंदुओं को स्पष्ट करना चाहता हूं जिन्हें मैं इस लेख के साथ साबित करने की कोशिश नहीं करता हूं:

1. मैं यह नहीं कह रहा हूं कि इन सुविधाओं को सभी भूल गए हैं या वे अनिवार्य रूप से ऐसे हैं। मुझे उनके लिए व्यक्तिगत रूप से मुश्किल लगता है (उदाहरण के लिए, विवरण भूल जाते हैं यदि वे स्मृति में ताज़ा नहीं होते हैं)। वे आपके लिए आसान हो सकते हैं। फिर भी, मुझे लगता है कि यह संग्रह न केवल मेरे लिए उपयोगी हो सकता है।

2. मैं यह नहीं कह रहा हूं कि आपको भाषा के इन हिस्सों का उपयोग करने की आवश्यकता है, लेकिन केवल यह दावा करें कि यदि आप उन्हें जानते हैं, तो आप अन्य डेवलपर्स के कोड को आसानी से पढ़ सकते हैं। उनमें से ज्यादातर उपयोगी हो सकते हैं, लेकिन कोड में उनकी उपस्थिति हमेशा सबसे अच्छा समाधान नहीं होती है।

3. मैं ES5 के फीचर्स को नहीं छूता - न तो स्ट्रिक्ट, न ही सामान्य रूप से, न ही ES6 सामान्य रूप से। मैं उनके बारे में बाद में बात करूंगा। मैं स्वीकार करता हूं कि चर्चा की गई कुछ विशेषताएं ECMAScript के भविष्य के संस्करणों में बदल रही हैं या विकसित हो रही हैं।

इसके साथ ही कहा, शुरू करते हैं।

1. 1.0 = +0 = 0 (या सख्त शून्य सकारात्मक और नकारात्मक शून्य के बराबर है)

जावास्क्रिप्ट में 0 और +0 का मान होता है जो दर्शाता है कि आप किस तरफ शून्य पर गए हैं। लेकिन यह तुलना करते समय सख्त शून्य में परिवर्तित हो जाता है।
jsfiddle.net/codylindley/6phD9/light

console.log(-0); //logs 0 console.log(+0); //logs 0 console.log(-0 === +0); //logs true console.log(0 === -0); //logs true console.log(0 === +0); //logs true 

2. नया शब्द कंस्ट्रक्टर को स्वतंत्र रूप से निष्पादित कर सकता है

तर्क के बिना एक निर्माता को कॉल एक नए कीवर्ड के साथ किया जा सकता है, बिना कंस्ट्रक्टर के बाद कोष्ठक लिखे बिना।
jsfiddle.net/codylindley/nHCvx/light

 var Human = function(){ this.type = 'human'; console.log('I was called'); }; new Human; //       "I was called" console.log((new Human).type); // human (  ) 

3. Instof आदिम के साथ काम नहीं करता है

Instof ऑपरेटर स्ट्रिंग्स, संख्याओं और तार्किक चर के लिए गलत देता है। यदि वे वस्तुओं में स्थित हैं (अर्थात, आदिम के आवरण में), तो यह सामान्य रूप से काम करता है। याद रखें कि अशक्त और अपरिभाषित एक वस्तु आवरण नहीं है।
jsfiddle.net/codylindley/bpJjZ/light

 //instanceof     console.log("" instanceof String); // false console.log(3 instanceof Number); // false console.log(false instanceof Boolean); // false //instanceof     () console.log(new String() instanceof String); // true console.log(new Number() instanceof Number); // true console.log(new Boolean() instanceof Boolean); // true console.log([] instanceof Array); // true console.log({} instanceof Object); // true console.log(/foo/ instanceof RegExp); // true // , console.log([] instanceof Object); // true 

4. टाइपऑफ़ ऑपरेटर - गैर-सार्वभौमिक और त्रुटियों के साथ

टाइपोफ़ की प्रयोज्यता आदिमता तक सीमित है, लेकिन इसमें एक त्रुटि भी है: (टाइपोफ़ नल === "ऑब्जेक्ट") == सच है, यही वजह है कि चेक के स्व-लिखित और बैसाखी तरीके सबसे अच्छे हैं। /
jsfiddle.net/codylindley/U64aZ/light

 //    string, number,  boolean console.log(typeof ""); // "string" console.log(typeof 4); // number console.log(typeof true); // boolean console.log(typeof undefined); // undefined // ,    null console.log(typeof null); //?? !  Object 

5. झूठे मूल्यों से बूलियन वस्तु हमेशा सच होती है

 console.log(!!(new Boolean(false)) ) //true 

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

6. तर्क या फ़ंक्शन पैरामीटर?

जब फ़ंक्शन कहा जाता है तो तर्क का उपयोग किया जाता है। हम कार्यों के लिए तर्क देते हैं। फ़ंक्शन निर्धारित होने के समय पैरामीटर सेट किए जाते हैं। इस प्रकार, यह कहा जाता है कि किसी फ़ंक्शन को परिभाषित करने के लिए मापदंडों का उपयोग किया जाता है। इन शब्दों का परस्पर प्रयोग किया जाता है, लेकिन उनके अंतर को जानने से काम आ सकता है।
jsfiddle.net/codylindley/8Zkdd/light

 var myFunction = function(x,y,z){ //x,y,z -  return x+y+z }; myFunction(1,2,3); //1,2,3 -  

7. एक पैरामीटर के मूल्य को बदलने से तर्क का मूल्य नहीं बदलता है

उदाहरण के लिए, यदि आप किसी फ़ंक्शन में सरणी पास करते हैं, तो पैरामीटर मान को बदलने से मूल पैरामीटर मान नहीं बदलेगा।
jsfiddle.net/codylindley/c2xb4/light

 var myFunction = function(parameter){ parameter = undefined; //    undefiend console.log(parameter); }; var myArray = [1,2,3]; myFunction(myArray); // myFunction,   //myArray -  undefined ,   ,        console.log(myArray); //logs [1,2,3] 

8. बुलियन () को एक फ़ंक्शन के रूप में कॉल करना किसी भी मूल्य को बूलियन में परिवर्तित करता है

एक तर्क के साथ एक फ़ंक्शन (नए के बिना) के रूप में निर्माणकर्ता को कॉल करना इसे तार्किक में परिवर्तित करता है।

jsfiddle.net/codylindley/4wQLd/light

 //,  ,  false console.log(Boolean(undefined)); console.log(Boolean(null)); console.log(Boolean(0)); console.log(Boolean('')); console.log(Boolean(NaN)); //,  ,  true console.log(Boolean(1)); console.log(Boolean('false')); console.log(Boolean([])); console.log(Boolean({})); console.log(Boolean(function(){})); console.log(Boolean(/foo/)); 

बेशक, दोहरा उलटा !! () एक ही प्रभाव देगा। लेकिन यह मुझे पसंद करने के लिए पर्याप्त अभिव्यंजक नहीं है।
jsfiddle.net/codylindley/jNPvH/light

 //,  ,  false console.log(!!undefined); console.log(!!null); console.log(!!0); console.log(!!''); console.log(!!NaN); //,  ,  true console.log(!!1); console.log(!!'false'); console.log(!![]); console.log(!!{}); console.log(!!function(){}); console.log(!!/foo/); 

9. नए रिटर्न आदिम के बिना आदिम वस्तुओं के निर्माता को कॉल करना

jsfiddle.net/codylindley/ymGmG/light

 // true console.log(String('foo') === 'foo'); console.log(Number(5) === 5); console.log(Boolean('true') === true); // false,      console.log(new String('foo') === 'foo'); console.log(new Number(5) === 5); console.log(new Boolean('true') === true); 

10. ऑब्जेक्ट () आदिम के ऑब्जेक्ट रैपर बनाता है

अन्य कंस्ट्रक्टरों के विपरीत, ऑब्जेक्ट () रैपर्स में प्रिमिटिव को लपेटता है।
jsfiddle.net/codylindley/tGChw/light

 // number    console.log(Object(1) instanceof Number); //logs true // string    console.log(Object('foo') instanceof String); // boolean    console.log(Object(true) instanceof Boolean); 

11. आदिम के गुणों तक पहुंच एक त्रुटि को छिपाती है

सब कुछ पूरी तरह से आदिम में लिखा है, कोई फर्क नहीं पड़ता कि कौन कहता है। पढ़ने में कोई दिक्कत नहीं हैं। सिवाय इसके कि इसे हमेशा अपरिभाषित पढ़ा जाता है। कारण यह है कि आदिम के लिए ऑब्जेक्ट रैपर नहीं बनाया गया है ।
jsfiddle.net/codylindley/E7GGK/light

 //  var N = 5; var S = 'foo'; var B = true; //   ,  ,       N.test = 'test'; S.test = 'test'; B.test = 'test'; //,     console.log(N.test); // undefined console.log(S.test); // undefined console.log(B.test); // undefined 

12. हटाएं विरासत में मिली संपत्तियों को नहीं हटाता है

jsfiddle.net/codylindley/xYsuS/light

 var Person = function(){}; //  Person Person.prototype.type = 'person'; //  var cody = new Person(); // Person delete cody.type // (?) type console.log(cody.type) // person,        

13. स्ट्रिंग्स के ऑब्जेक्ट गोले सरणी की तरह हैं

क्योंकि स्ट्रिंग ऑब्जेक्ट का शेल एक सरणी जैसी ऑब्जेक्ट बनाता है, (अर्थात कंसोल.लॉग (नया स्ट्रिंग ('फू')); // प्रिंट्स फू {0 = "एफ", 1 = "ओ", 2 = "O"}, आप चरित्र अनुक्रमण (IE7- को छोड़कर) का उपयोग कर सकते हैं।
jsfiddle.net/codylindley/7p2ed/light

 //  var foo = 'foo'; //      console.log(foo[0]) // "f",      {0="f", 1="o", 2="o"} //       console.log(foo['length']); // 3 

14. संख्याओं के आदिम से गुणों तक पहुँच

संख्या के आदिम के बाद पहला बिंदु एक दशमलव बिंदु के रूप में मान्यता प्राप्त है और संपत्ति तक पहुंचने के अर्थ में बिंदु के साथ संघर्ष करता है। लेकिन दूसरा ...
jsfiddle.net/codylindley/Pn6YT/light

 //  console.log(2['toString']()); //logs 2 //       . console.log(2..toString()); //logs 2 //    console.log((2).toString()); //logs 2 

15. Array.length फिर से लिखी जा सकती है, जिसके दुष्प्रभाव हैं

स्पष्ट रूप से लंबाई संपत्ति निर्दिष्ट करके, आप सरणी के अंत में अपरिभाषित मानों की एक श्रृंखला जोड़ सकते हैं या सरणी को छोटा कर सकते हैं।
jsfiddle.net/codylindley/9Pp9h/light

 var myArray1 = []; myArray1.length = 3; console.log(myArray1); // [undefined, undefined, undefined] //   myArray2 = [1,2,3,4,5,6,7,8,9] myArray2.length = 1; console.log(myArray2); // [1] 

16. तार्किक ऑपरेटर "||" पहले सच्चे मूल्य पर काम करता है

यदि इस कथन में बाएं तर्क का मान सत्य पर सेट किया गया है, तो सही मान की गणना नहीं की जाएगी, जिसे लाक्षणिक रूप से "लघु-परिच्छेद" (लघु-परिच्छेद, लघु-परिच्छेद, या इस मामले में "" लघु जाना ") कहा जाता है। वास्तव में, पहले मूल्य में सत्य का पता लगाने से उनके छिपे हुए बसेरों में अपरिवर्तित मूल्यों के दाईं ओर कार्यों और अभिव्यक्तियों को नहीं छूना पड़ता है।
jsfiddle.net/codylindley/NUKKZ/light

 //  ,   true,     var foo = false || 0 || '' || 4 || 'foo' || true; console.log(foo); // 4,     //        

17. तार्किक ऑपरेटर "&&" पहले गलत मान पर चलता है

इसी तरह, लेकिन एक रिवर्स लॉजिकल वैल्यू के साथ, इसे तब तक क्रियान्वित किया जाता है, जब तक कि पहला फाउल समावेशी नहीं हो जाता।
jsfiddle.net/codylindley/DEbk5/light

 //  ,   false,     var foo = true && 'foo' && '' && 4 && 'foo' && true; console.log(foo); // '',      false 

18. अशक्त का उपयोग कब करें, और कब - अपरिभाषित?

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

19. डिफ़ॉल्ट रूप से अपरिभाषित

अपरिभाषित मूल्य के अभाव का वर्णन करता है। निम्न उदाहरण मान नहीं बनाते हैं (अपरिभाषित वापसी)।
jsfiddle.net/codylindley/3buPG/light
jsfiddle.net/codylindley/3buPG/light

 //    -    var foo; console.log(foo); //undefined //      undefined console.log(this.foo); //undefined //   ,  ,   undefined- var myFunction = function f(x){return x} console.log(myFunction()); //undefined //  undefined,     return  var myFunc = function f(){}; console.log(myFunc()); //undefined 

20. एक अभिव्यक्ति काम कर सकती है जहां ऑपरेटर नहीं कर सकता है

अभिव्यक्तियाँ मान लौटाती हैं, जबकि ऑपरेटर कार्रवाई करते हैं, जो सशर्त अभिव्यक्ति के लिए यदि और एक टर्नरी तार्किक ऑपरेटर के बीच अंतर के उदाहरण द्वारा स्पष्ट रूप से चित्रित किया गया है। "यदि मैं फ़ंक्शन मापदंडों को निर्दिष्ट करते समय काम नहीं कर सकता, तो एक सशर्त अभिव्यक्ति हो सकती है।
jsfiddle.net/codylindley/SSh68/light

 var verify = true; // if     if(verify){console.log('verify is true');} //   ,       //   (  --..) var check = verify ? console.log('verify is true') : console.log('verify is false'); //    console.log(verify ? 'verify is true' : ' verify is false'); 

21. ऑपरेटरों का स्थान ++ और -

यदि ऑपरेटर्स उपसर्ग (वेरिएबल से पहले) हैं, तो पहले मूल्य बदल दिया जाता है, फिर इसे एक्सप्रेशन पर लौटा दिया जाता है। यदि पोस्टफ़िक्स - अभिव्यक्ति के लिए प्रारंभिक मूल्य वापस आ गया है, लेकिन रिटर्न से पहले चर को बदल दिया जाता है।
jsfiddle.net/codylindley/QzG9w/light

 http://jsfiddle.net/codylindley/QzG9w/light/ var boo = 1; var foo = 1; console.log(boo++); // 1,   console.log(boo)   2 console.log(++foo); // 2,    foo