दिलचस्प पोस्ट
एक चुनिंदा बॉक्स से आइटम निकालना IPhone अनुप्रयोगों की चोरी को कम करना सी # या .NET में आपने अजीब कोने के मामले में क्या देखा है? PHP, कैसे शून्य से एक विभाजन पकड़ने के लिए? एंड्रॉइड में एक ListView में छवियों की एक सूची प्रदर्शित करने के लिए कैसे? सीएसएस मीडिया प्रश्नों की चौड़ाई और न्यूनतम-डिवाइस चौड़ाई परस्पर विरोधी है? गैर शून्य निकास मूल्य के साथ समाप्त जावास्क्रिप्ट ऑनलोड इवेंट से प्रबंधन की विधि निष्पादित करें PHP में एक वेरिएबल के अंदर व्हाइटस्पेस पट्टी करना क्या कोई ऐसा तरीका है जिससे उनकी कक्षा नाम वाले स्ट्रिंग से वस्तुओं को इन्स्तांत किया जा सकता है? पोस्टग्रेज़: INSERT अगर पहले से मौजूद नहीं है अजगर – फ़ाइल बनाम खोलने के लिए कब उपयोग करें आर में लम्बी / बिल्टीन्ट / दशमलव समतुल्य डेटाटाइप प्रक्रिया का उपयोग कर एक फ़ोल्डर खोलें। प्रारंभ करें आप एक स्क्रिप्ट प्रोफ़ाइल कैसे कर सकते हैं?

जावास्क्रिप्ट की छिपी हुई विशेषताओं?

जावास्क्रिप्ट के "छिपी हुई विशेषताएं" क्या आपको लगता है कि हर प्रोग्रामर को पता होना चाहिए?

निम्नलिखित प्रश्नों के उत्तर की उत्कृष्ट गुणवत्ता के बाद मैंने सोचा कि यह जावास्क्रिप्ट के लिए पूछने का समय था।

  • एचटीएमएल की छिपी हुई विशेषताओं
  • सीएसएस की छिपी हुई विशेषताओं
  • PHP की छिपी हुई विशेषताओं
  • एएसपी.नेट की छिपी हुई विशेषताओं
  • सी # की छिपी सुविधाएँ
  • जावा की छुपी हुई विशेषताएं
  • पायथन की छिपी हुई विशेषताओं

भले ही जावास्क्रिप्ट अभी तक सबसे महत्वपूर्ण क्लाइंट साइड भाषा है (बस Google से पूछो) यह आश्चर्यजनक है कि कितने सबसे अधिक वेब डेवलपर्स इसकी सराहना करते हैं कि यह वास्तव में कितना शक्तिशाली है

Solutions Collecting From Web of "जावास्क्रिप्ट की छिपी हुई विशेषताओं?"

फ़ंक्शन के लिए किसी भी पैरामीटर को परिभाषित करने की आवश्यकता नहीं है। आप फ़ंक्शन के arguments की तरह-तरह की ऑब्जेक्ट का उपयोग कर सकते हैं।

 function sum() { var retval = 0; for (var i = 0, len = arguments.length; i < len; ++i) { retval += arguments[i]; } return retval; } sum(1, 2, 3) // returns 6 

मैं डगलस क्रॉकफोर्ड के उत्कृष्ट पुस्तक जावास्क्रिप्ट: द गुड पार्ट्स

लेकिन मैं सिर्फ तुम्हारे लिए एक लेता हूँ, हमेशा === और !== बजाय == और !=

 alert('' == '0'); //false alert(0 == ''); // true alert(0 =='0'); // true 

== संक्रमणीय नहीं है यदि आप === उपयोग करते हैं तो यह अपेक्षित सभी बयानों के लिए झूठा होगा।

कार्य जावास्क्रिप्ट में प्रथम श्रेणी के नागरिक हैं:

 var passFunAndApply = function (fn,x,y,z) { return fn(x,y,z); }; var sum = function(x,y,z) { return x+y+z; }; alert( passFunAndApply(sum,3,4,5) ); // 12 

कार्यात्मक प्रोग्रामिंग तकनीकों को सुरुचिपूर्ण जावास्क्रिप्ट लिखने के लिए इस्तेमाल किया जा सकता है ।

विशेष रूप से, फ़ंक्शन पैरामीटर के रूप में पारित किए जा सकते हैं, जैसे कि Array.filter () एक कॉलबैक स्वीकार करता है:

 [1, 2, -1].filter(function(element, index, array) { return element > 0 }); // -> [1,2] 

आप एक "निजी" फ़ंक्शन को भी घोषित कर सकते हैं जो केवल किसी विशिष्ट फ़ंक्शन के दायरे में मौजूद है:

 function PrintName() { var privateFunction = function() { return "Steve"; }; return privateFunction(); } 

आप एक ऑपरेटर में यह जांचने के लिए उपयोग कर सकते हैं कि कोई वस्तु वस्तु में मौजूद है या नहीं:

 var x = 1; var y = 3; var list = {0:0, 1:0, 2:0}; x in list; //true y in list; //false 1 in list; //true y in {3:0, 4:0, 5:0}; //true 

यदि आप ऑब्जेक्ट लिटरल्स को बहुत बदसूरत पाते हैं तो आप पैरालेसलेस फ़ंक्शन टिप के साथ इसे जोड़ सकते हैं:

 function list() { var x = {}; for(var i=0; i < arguments.length; ++i) x[arguments[i]] = 0; return x } 5 in list(1,2,3,4,5) //true 

चर के लिए डिफ़ॉल्ट मान असाइन करना

आप तार्किक या ऑपरेटर का उपयोग कर सकते हैं || एक डिफ़ॉल्ट मान प्रदान करने के लिए असाइनमेंट अभिव्यक्ति में:

 var a = b || c; 

a चर को केवल c का मान मिल जाएगा यदि b falsy है (यदि null , false , undefined , 0 , empty string , या NaN ), अन्यथा a को b का मान मिल जाएगा।

यह फ़ंक्शंस में अक्सर उपयोगी होता है, जब आप एक तर्क के लिए एक डिफ़ॉल्ट मान देना चाहते हैं, तो यह आपूर्ति नहीं की जा सकती है:

 function example(arg1) { arg1 || (arg1 = 'default value'); } 

घटना संचालकों में उदाहरण IE फॉलबैक:

 function onClick(e) { e || (e = window.event); } 

निम्नलिखित भाषा सुविधाओं हमारे साथ बहुत लंबे समय तक रही हैं, सभी जावास्क्रिप्ट लागूकरण उनका समर्थन करते हैं, लेकिन वे ECMAScript 5 वीं संस्करण तक विनिर्देशन का हिस्सा नहीं थे:

debugger स्टेटमेंट

में उल्लिखित : § 12.15 डीबगर बयान

यह कथन आपको आपके कोड में ब्रेकपॉइंट प्रोग्रामेटिक रूप से अपने कोड में डाल करने की अनुमति देता है:

 // ... debugger; // ... 

यदि कोई डिबगर मौजूद है या सक्रिय है, तो वह इसे तुरंत तोड़ने का कारण होगा, ठीक उसी रेखा पर

अन्यथा, यदि डीबगर मौजूद नहीं है या सक्रिय है तो इस कथन में कोई प्रभाव नहीं पड़ता है।

मल्टीलाइन स्टिंग लीटरल्स

में वर्णित: § 7.8.4 स्ट्रिंग लीटरल

 var str = "This is a \ really, really \ long line!"; 

आपको सावधान रहना होगा क्योंकि \ लाइन टर्मिनेटर \ पास वाला चरित्र होना चाहिए, उदाहरण के लिए यदि आपके पास एक स्थान है, तो कोड बिल्कुल समान दिखेगा , लेकिन यह एक SyntaxError बढ़ाएगा।

जावास्क्रिप्ट में ब्लॉक स्कोप नहीं है (लेकिन यह बंद है, तो हम इसे भी कहते हैं?)

 var x = 1; { var x = 2; } alert(x); // outputs 2 

आप ऑब्जेक्ट प्रॉपर्टी को [] बजाय का उपयोग कर सकते हैं .

यह आपको एक चर के साथ मिलान करने वाला एक संपत्ति देखने की अनुमति देता है

 obj = {a:"test"}; var propname = "a"; var b = obj[propname]; // "test" 

आप इसका उपयोग वसूली गुण प्राप्त करने / सेट करने के लिए भी कर सकते हैं, जिनका नाम कानूनी पहचानकर्ता नहीं है

 obj["class"] = "test"; // class is a reserved word; obj.class would be illegal. obj["two words"] = "test2"; // using dot operator not possible with the space. 

कुछ लोगों को यह पता नहीं है और इस तरह eval () का उपयोग कर समाप्त होता है, जो वास्तव में एक बुरा विचार है :

 var propname = "a"; var a = eval("obj." + propname); 

यह पढ़ने में कठिन है, में त्रुटियों को खोजने के लिए कठिन (जेएस लिंट का उपयोग नहीं किया जा सकता), निष्पादित करने के लिए धीमा, और एक्सएसएस शोषण का कारण बन सकता है।

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

गूगल: जावास्क्रिप्ट सरणी सॉर्ट एमडीसी
(ज्यादातर मामलों में आप "जावास्क्रिप्ट" छोड़ सकते हैं)

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

शायद कुछ को कुछ स्पष्ट …

फायरबग इंस्टॉल करें और console.log ("हैलो") का उपयोग करें। इतना यादृच्छिक चेतावनी (); 'मुझे याद है जो कुछ साल पहले बहुत कुछ करने से बेहतर है।

निजी तरीके

किसी ऑब्जेक्ट के पास निजी तरीके हो सकते हैं।

 function Person(firstName, lastName) { this.firstName = firstName; this.lastName = lastName; // A private method only visible from within this constructor function calcFullName() { return firstName + " " + lastName; } // A public method available to everyone this.sayHello = function () { alert(calcFullName()); } } //Usage: var person1 = new Person("Bob", "Loblaw"); person1.sayHello(); // This fails since the method is not visible from this scope alert(person1.calcFullName()); 

क्रॉकफोर्ड के "जावास्क्रिप्ट: द गुड पार्ट्स" में भी उल्लेख किया गया है:

parseInt() खतरनाक है यदि आप इसे उचित आधार के बिना सूचित किए बिना एक स्ट्रिंग पास करते हैं तो यह अप्रत्याशित संख्या वापस कर सकती है। उदाहरण के लिए parseInt('010') 8 देता है, 10 नहीं। ParseInt के लिए आधार पास करने से यह सही ढंग से काम करता है:

 parseInt('010') // returns 8! (in FF3) parseInt('010', 10); // returns 10 because we've informed it which base to work with. 

कार्य वस्तुओं हैं और इसलिए गुण हो सकते हैं।

 fn = फ़ंक्शन (x) {
    // ...
 }

 fn.foo = 1;

 fn.next = फ़ंक्शन (y) {
   //
 }

मुझे आत्म-निष्पादन कार्यों को कहना होगा

 (function() { alert("hi there");})(); 

चूंकि जावास्क्रिप्ट में ब्लॉक स्कोप नहीं है , यदि आप स्थानीय चर को परिभाषित करना चाहते हैं तो आप स्वयं निष्पादन फ़ंक्शन का उपयोग कर सकते हैं:

 (function() { var myvar = 2; alert(myvar); })(); 

यहां, myvar वैश्विक दायरे में हस्तक्षेप या प्रदूषित नहीं करता है, और myvar समाप्त होने पर गायब हो जाता है।

फ़ंक्शन द्वारा कितने मापदंडों की अपेक्षा करें

 function add_nums(num1, num2, num3 ){ return num1 + num2 + num3; } add_nums.length // 3 is the number of parameters expected. 

फ़ंक्शन द्वारा कितने पैरामीटर प्राप्त होते हैं

 function add_many_nums(){ return arguments.length; } add_many_nums(2,1,122,12,21,89); //returns 6 

यहां कुछ रोचक चीजें हैं:

  • किसी भी चीज़ के साथ NaN तुलना (यहां तक ​​कि NaN ) हमेशा झूठी है, जिसमें शामिल है == , < और >
  • NaN संख्या के लिए नहीं खड़ा है, लेकिन यदि आप इस प्रकार की मांग करते हैं तो यह वास्तव में एक नंबर देता है
  • Array.sort एक तुलनित्र फ़ंक्शन ले सकता है और उसे एक Array.sort -जैसे चालक (कार्यान्वयन पर निर्भर करता है) द्वारा कहा जाता है।
  • नियमित अभिव्यक्ति "स्थिरांक" राज्य को बनाए रख सकते हैं, जैसे वे आखिरी चीज से मेल खाते हैं
  • जावास्क्रिप्ट के कुछ संस्करणों में आपको $0 , $1 , $2 रीजक्स पर सदस्यों का उपयोग करने की अनुमति मिलती है।
  • null कुछ और के विपरीत है यह न तो एक वस्तु है, एक बूलीयन, एक संख्या, एक स्ट्रिंग, और न ही undefined । यह एक "वैकल्पिक" undefined तरह थोड़ा सा है (नोट: typeof null == "object" )
  • बाहरी संदर्भ में, this अन्यथा अनजान [ग्लोबल] वस्तु उत्पन्न करता है
  • वेरिएबल को वैरिएबल घोषित करने के बजाय चर की स्वचालित घोषणा पर निर्भर होने के बजाय रनटाइम को उस वेरिएबल तक पहुंच के अनुकूलन का एक वास्तविक मौका मिलता है
  • निर्माण के with ऐसी आशाओं को नष्ट कर देगा
  • चर नामों में यूनिकोड वर्ण शामिल हो सकते हैं।
  • जावास्क्रिप्ट नियमित अभिव्यक्ति वास्तव में नियमित नहीं हैं वे पर्ल के regexs पर आधारित हैं, और lookaheads के साथ भाव का निर्माण संभव है कि मूल्यांकन करने के लिए बहुत, बहुत लंबे समय लेते हैं।
  • ब्लॉक को break के लक्ष्य के रूप में लेबल और इस्तेमाल किया जा सकता है। लूप को continue के लक्ष्य के रूप में लेबल और उपयोग किया जा सकता है।
  • सरणी विरल नहीं हैं एक अन्यथा रिक्त अरै के 1000 वें तत्व को सेट अप को undefined भरना चाहिए। (कार्यान्वयन पर निर्भर करता है)
  • if (new Boolean(false)) {...} {...} ब्लॉक को निष्पादित करेगा
  • जावास्क्रिप्ट के नियमित अभिव्यक्ति इंजन का कार्यान्वयन विशिष्ट है: उदाहरण के लिए "गैर-पोर्टेबल" नियमित अभिव्यक्तियां लिखना संभव है।

[अच्छी टिप्पणियों के जवाब में थोड़ा अपडेट किया; कृपया टिप्पणियां देखें]

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

 // Quick hex to dec conversion: +"0xFF"; // -> 255 // Get a timestamp for now, the equivalent of `new Date().getTime()`: +new Date(); // Safer parsing than parseFloat()/parseInt() parseInt("1,000"); // -> 1, not 1000 +"1,000"; // -> NaN, much better for testing user input parseInt("010"); // -> 8, because of the octal literal prefix +"010"; // -> 10, `Number()` doesn't parse octal literals // A use case for this would be rare, but still useful in cases // for shortening something like if (someVar === null) someVar = 0; +null; // -> 0; // Boolean to integer +true; // -> 1; +false; // -> 0; // Other useful tidbits: +"1e10"; // -> 10000000000 +"1e-4"; // -> 0.0001 +"-12"; // -> -12 

बेशक, आप इसके बजाय Number() का उपयोग करके यह सब कर सकते हैं, लेकिन + ऑपरेटर बहुत सुंदर है!

आप प्रोटोटाइप के मूल्य valueOf() विधि को ओवरराइड करके एक ऑब्जेक्ट के लिए एक संख्यात्मक रिटर्न मान भी परिभाषित कर सकते हैं। उस ऑब्जेक्ट पर किए गए किसी भी संख्या रूपांतरण का परिणाम NaN न हो, लेकिन valueOf() विधि का रिटर्न वैल्यू:

 var rnd = { "valueOf": function () { return Math.floor(Math.random()*1000); } }; +rnd; // -> 442; +rnd; // -> 727; +rnd; // -> 718; 

प्रोटोटाइप संपत्ति के माध्यम से " जावास्क्रिप्ट में विस्तार तरीकों "

 Array.prototype.contains = function(value) { for (var i = 0; i < this.length; i++) { if (this[i] == value) return true; } return false; } 

यह सभी Array ऑब्जेक्ट्स contains एक contains विधि जोड़ देगा। आप इस वाक्यविन्यास का उपयोग करके इस विधि को कॉल कर सकते हैं

 var stringArray = ["foo", "bar", "foobar"]; stringArray.contains("foobar"); 

ऑब्जेक्ट से एक संपत्ति को ठीक से निकालने के लिए, आपको इसे अपरिभाषित करने के बजाय संपत्ति को हटाना चाहिए:

 var obj = { prop1: 42, prop2: 43 }; obj.prop2 = undefined; for (var key in obj) { ... 

संपत्ति prop2 अभी भी चलना का हिस्सा होगा। यदि आप पूरी तरह से प्रोप 2 से छुटकारा चाहते हैं, तो आपको इसके बजाय करना चाहिए:

 delete obj.prop2; 

प्रॉपर्टी प्रॉप 2 अब जब आप प्रॉपर्टी के माध्यम से पुनरावृत्त हो जाएंगे तो एक उपस्थिति नहीं बनाएगा।

with

यह शायद ही कभी प्रयोग किया जाता है, और स्पष्ट रूप से, शायद ही कभी उपयोगी … लेकिन, सीमित परिस्थितियों में, इसका उपयोग करता है

उदाहरण के लिए: ऑब्जेक्ट लिटरल्स एक नए ऑब्जेक्ट पर जल्दी से गुण स्थापित करने के लिए काफी आसान हैं I लेकिन क्या होगा यदि आपको मौजूदा ऑब्जेक्ट पर आधा संपत्ति बदलने की जरूरत है?

 var user = { fname: 'Rocket', mname: 'Aloysus', lname: 'Squirrel', city: 'Fresno', state: 'California' }; // ... with (user) { mname = 'J'; city = 'Frostbite Falls'; state = 'Minnesota'; } 

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

 var user = { fname: "John", // mname definition skipped - no middle name lname: "Doe" }; with (user) { mname = "Q"; // creates / modifies global variable "mname" } 

इसलिए, यह शायद एक अच्छा विचार है कि इस तरह की असाइनमेंट के लिए बयान के उपयोग से बचें।

यह भी देखें: क्या जावास्क्रिप्ट के "साथ" कथन के लिए कोई वैध उपयोग होता है?

तरीकों (या फ़ंक्शन) को उस ऑब्जेक्ट पर कॉल किया जा सकता है जो कि उन प्रकार के नहीं होते हैं जिनके साथ वे काम करने के लिए डिज़ाइन किए गए थे। कस्टम ऑब्जेक्ट्स पर देशी (तेज़) तरीके कॉल करने के लिए यह बहुत अच्छा है

 var listNodes = document.getElementsByTagName('a'); listNodes.sort(function(a, b){ ... }); 

यह कोड क्रैश क्योंकि listNodes एक Array नहीं है

 Array.prototype.sort.apply(listNodes, [function(a, b){ ... }]); 

यह कोड कार्य करता है क्योंकि listNodes sort() द्वारा उपयोग किए जाने वाले पर्याप्त सरणी-जैसी गुण (लंबाई, [] ऑपरेटर) को परिभाषित करता है।

प्रोटोटाइप विरासत (डगलस क्रॉकफोर्ड द्वारा लोकप्रिय) पूरी तरह से आपको जावास्क्रिप्ट में चीजों के भार के बारे में सोचने के तरीके में क्रांतिकारी परिवर्तन करता है।

 Object.beget = (function(Function){ return function(Object){ Function.prototype = Object; return new Function; } })(function(){}); 

यह एक हत्यारा है! दया कैसे लगभग कोई भी इसका इस्तेमाल नहीं करता है

यह आपको किसी अन्य वस्तु के नए उदाहरणों को "उत्पन्न" करने की अनुमति देता है, उनका विस्तार करता है, जबकि उनके अन्य गुणों के लिए (लाइव) प्रोटोटाइपिकल इनहेरिटन्स लिंक को बनाए रखता है। उदाहरण:

 var A = { foo : 'greetings' }; var B = Object.beget(A); alert(B.foo); // 'greetings' // changes and additionns to A are reflected in B A.foo = 'hello'; alert(B.foo); // 'hello' A.bar = 'world'; alert(B.bar); // 'world' // ...but not the other way around B.foo = 'wazzap'; alert(A.foo); // 'hello' B.bar = 'universe'; alert(A.bar); // 'world' 

कुछ इसे स्वाद की बात कहते हैं, लेकिन:

 aWizz = wizz || "default"; // same as: if (wizz) { aWizz = wizz; } else { aWizz = "default"; } 

The trinary operator can be chained to act like Scheme's (cond …):

 (cond (predicate (action ...)) (predicate2 (action2 ...)) (#t default )) 

can be written as…

 predicate ? action( ... ) : predicate2 ? action2( ... ) : default; 

This is very "functional", as it branches your code without side effects. इसके बजाय:

 if (predicate) { foo = "one"; } else if (predicate2) { foo = "two"; } else { foo = "default"; } 

तुम लिख सकते हो:

 foo = predicate ? "one" : predicate2 ? "two" : "default"; 

Works nice with recursion, too 🙂

Numbers are also objects. So you can do cool stuff like:

 // convert to base 2 (5).toString(2) // returns "101" // provide built in iteration Number.prototype.times = function(funct){ if(typeof funct === 'function') { for(var i = 0;i < Math.floor(this);i++) { funct(i); } } return this; } (5).times(function(i){ string += i+" "; }); // string now equals "0 1 2 3 4 " var x = 1000; x.times(function(i){ document.body.innerHTML += '<p>paragraph #'+i+'</p>'; }); // adds 1000 parapraphs to the document 

How about closures in JavaScript (similar to anonymous methods in C# v2.0+). You can create a function that creates a function or "expression".

Example of closures :

 //Takes a function that filters numbers and calls the function on //it to build up a list of numbers that satisfy the function. function filter(filterFunction, numbers) { var filteredNumbers = []; for (var index = 0; index < numbers.length; index++) { if (filterFunction(numbers[index]) == true) { filteredNumbers.push(numbers[index]); } } return filteredNumbers; } //Creates a function (closure) that will remember the value "lowerBound" //that gets passed in and keep a copy of it. function buildGreaterThanFunction(lowerBound) { return function (numberToCheck) { return (numberToCheck > lowerBound) ? true : false; }; } var numbers = [1, 15, 20, 4, 11, 9, 77, 102, 6]; var greaterThan7 = buildGreaterThanFunction(7); var greaterThan15 = buildGreaterThanFunction(15); numbers = filter(greaterThan7, numbers); alert('Greater Than 7: ' + numbers); numbers = filter(greaterThan15, numbers); alert('Greater Than 15: ' + numbers); 

You can also extend (inherit) classes and override properties/methods using the prototype chain spoon16 alluded to.

In the following example we create a class Pet and define some properties. We also override the .toString() method inherited from Object.

After this we create a Dog class which extends Pet and overrides the .toString() method again changing it's behavior (polymorphism). In addition we add some other properties to the child class.

After this we check the inheritance chain to show off that Dog is still of type Dog, of type Pet, and of type Object.

 // Defines a Pet class constructor function Pet(name) { this.getName = function() { return name; }; this.setName = function(newName) { name = newName; }; } // Adds the Pet.toString() function for all Pet objects Pet.prototype.toString = function() { return 'This pets name is: ' + this.getName(); }; // end of class Pet // Define Dog class constructor (Dog : Pet) function Dog(name, breed) { // think Dog : base(name) Pet.call(this, name); this.getBreed = function() { return breed; }; } // this makes Dog.prototype inherit from Pet.prototype Dog.prototype = new Pet(); // Currently Pet.prototype.constructor // points to Pet. We want our Dog instances' // constructor to point to Dog. Dog.prototype.constructor = Dog; // Now we override Pet.prototype.toString Dog.prototype.toString = function() { return 'This dogs name is: ' + this.getName() + ', and its breed is: ' + this.getBreed(); }; // end of class Dog var parrotty = new Pet('Parrotty the Parrot'); var dog = new Dog('Buddy', 'Great Dane'); // test the new toString() alert(parrotty); alert(dog); // Testing instanceof (similar to the `is` operator) alert('Is dog instance of Dog? ' + (dog instanceof Dog)); //true alert('Is dog instance of Pet? ' + (dog instanceof Pet)); //true alert('Is dog instance of Object? ' + (dog instanceof Object)); //true 

Both answers to this question were codes modified from a great MSDN article by Ray Djajadinata.

You may catch exceptions depending on their type. Quoted from MDC :

 try { myroutine(); // may throw three exceptions } catch (e if e instanceof TypeError) { // statements to handle TypeError exceptions } catch (e if e instanceof RangeError) { // statements to handle RangeError exceptions } catch (e if e instanceof EvalError) { // statements to handle EvalError exceptions } catch (e) { // statements to handle any unspecified exceptions logMyErrors(e); // pass exception object to error handler } 

NOTE: Conditional catch clauses are a Netscape (and hence Mozilla/Firefox) extension that is not part of the ECMAScript specification and hence cannot be relied upon except on particular browsers.

Off the top of my head…

कार्य

arguments.callee refers to the function that hosts the "arguments" variable, so it can be used to recurse anonymous functions:

 var recurse = function() { if (condition) arguments.callee(); //calls recurse() again } 

That's useful if you want to do something like this:

 //do something to all array items within an array recursively myArray.forEach(function(item) { if (item instanceof Array) item.forEach(arguments.callee) else {/*...*/} }) 

वस्तुओं

An interesting thing about object members: they can have any string as their names:

 //these are normal object members var obj = { a : function() {}, b : function() {} } //but we can do this too var rules = { ".layout .widget" : function(element) {}, "a[href]" : function(element) {} } /* this snippet searches the page for elements that match the CSS selectors and applies the respective function to them: */ for (var item in rules) { var elements = document.querySelectorAll(rules[item]); for (var e, i = 0; e = elements[i++];) rules[item](e); } 

Strings

String.split can take regular expressions as parameters:

 "hello world with spaces".split(/\s+/g); //returns an array: ["hello", "world", "with", "spaces"] 

String.replace can take a regular expression as a search parameter and a function as a replacement parameter:

 var i = 1; "foo bar baz ".replace(/\s+/g, function() {return i++}); //returns "foo1bar2baz3" 

You can use objects instead of switches most of the time.

 function getInnerText(o){ return o === null? null : { string: o, array: o.map(getInnerText).join(""), object:getInnerText(o["childNodes"]) }[typeis(o)]; } 

Update: if you're concerned about the cases evaluating in advance being inefficient (why are you worried about efficiency this early on in the design of the program??) then you can do something like this:

 function getInnerText(o){ return o === null? null : { string: function() { return o;}, array: function() { return o.map(getInnerText).join(""); }, object: function () { return getInnerText(o["childNodes"]; ) } }[typeis(o)](); } 

This is more onerous to type (or read) than either a switch or an object, but it preserves the benefits of using an object instead of a switch, detailed in the comments section below. This style also makes it more straightforward to spin this out into a proper "class" once it grows up enough.

update2: with proposed syntax extensions for ES.next, this becomes

 let getInnerText = o -> ({ string: o -> o, array: o -> o.map(getInnerText).join(""), object: o -> getInnerText(o["childNodes"]) }[ typeis o ] || (->null) )(o); 

Be sure to use the hasOwnProperty method when iterating through an object's properties:

 for (p in anObject) { if (anObject.hasOwnProperty(p)) { //Do stuff with p here } } 

This is done so that you will only access the direct properties of anObject , and not use the properties that are down the prototype chain.

Private variables with a Public Interface

It uses a neat little trick with a self-calling function definition. Everything inside the object which is returned is available in the public interface, while everything else is private.

 var test = function () { //private members var x = 1; var y = function () { return x * 2; }; //public interface return { setx : function (newx) { x = newx; }, gety : function () { return y(); } } }(); assert(undefined == test.x); assert(undefined == test.y); assert(2 == test.gety()); test.setx(5); assert(10 == test.gety());