दिलचस्प पोस्ट
वेबव्यू में फ़ाइल अपलोड करें रिटर्न कोई भी नहीं अगर शब्दकोश कुंजी उपलब्ध नहीं है पृष्ठभूमि कार्य से iOS 7 में स्थान प्रबंधक प्रारंभ करें नॉन-ओवरलैपिंग सरणी ब्लॉक्स प्राप्त करने के लिए नम्पी स्ट्राइड_ट्रिक्स का उपयोग करना जावा में पायथन कॉलिंग? ViewModel में एक बूल मान के लिए एक बटन की दृश्यता को बाध्य करना कतार में अगली फाइल खेलने में कोई देरी से बचने के लिए कतार में एमपी 3 फाइल प्रीलोड करें संचालकों को तार के रूप में jQuery कॉर्स सामग्री-प्रकार विकल्प Kerberos / Spring सुरक्षा / IE / सक्रिय निर्देशिका के साथ "दोषपूर्ण टोकन का पता चला" त्रुटि (NTLM नहीं कर्बोस) वर्चुअलवेन को अपने वैश्विक साइट-पैकेज से विशिष्ट पैकेजों का आदान-प्रदान करें MySQL: विशिष्ट मानों की संख्याओं की गणना करें हैंडलरथ्रेड के साथ संचार का उदाहरण जहां आप सी में नए चर की घोषणा कर सकते हैं और नहीं कर सकते हैं? उड़ने पर .htaccess (PHP) के साथ उपडोमेन बनाएँ

"यह" कीवर्ड कैसे काम करता है?

मैंने देखा है कि this कीवर्ड क्या है और this बारे में स्पष्ट स्पष्टीकरण नहीं है कि यह कैसे सही है (और गलत तरीके से) जावा स्क्रिप्ट ओवरफ्लो साइट पर उपयोग किया जाता है

मैंने इसके साथ कुछ बहुत ही अजीब व्यवहार देखा है और समझ में नहीं आया कि यह क्यों हुआ है।

यह कैसे काम करता है और इसका इस्तेमाल कब किया जाए?

Solutions Collecting From Web of ""यह" कीवर्ड कैसे काम करता है?"

मैं माइक वेस्ट के लेख को जावास्क्रिप्ट ( दर्पण ) में स्कोप पढ़ने की सलाह देता हूं यह जावास्क्रिप्ट में this की अवधारणाओं और गुंजाइशों के लिए उत्कृष्ट, मैत्रीपूर्ण परिचय है।

एक बार जब आप इसका इस्तेमाल करना शुरू this , तो ये नियम वास्तव में बहुत आसान होते हैं। ईसीएमएस्क्रिप्ट स्टैंडर्ड this एक कीवर्ड के रूप में परिभाषित करता है:

मौजूदा निष्पादन संदर्भ के इसबैंडिंग के मूल्य का मूल्यांकन करता है;

(§11.1.1)। यह बाइंडिंग ऐसा कुछ है जो जावास्क्रिप्ट दुभाषिया रखता है क्योंकि यह जावास्क्रिप्ट कोड का मूल्यांकन करता है, जैसे एक विशेष सीपीयू रजिस्टर जिसमें ऑब्जेक्ट का संदर्भ होता है। दुभाषिया केवल तीन अलग-अलग मामलों में से एक में निष्पादन संदर्भ की स्थापना करते समय यह बाइंडिंग अपडेट करता है:

  1. प्रारंभिक वैश्विक निष्पादन संदर्भ

    यह जावास्क्रिप्ट कोड का मामला है जिसका मूल्यांकन किया जाता है जब एक <script> तत्व का सामना होता है:

     <script type="text/javascript">//<![CDATA[ alert("I'm evaluated in the initial global execution context!"); setTimeout(function () { alert("I'm NOT evaluated in the initial global execution context."); }, 1); //]]></script> 

    प्रारंभिक वैश्विक निष्पादन के संदर्भ में कोड का मूल्यांकन करते समय, बायबिंग वैश्विक ऑब्जेक्ट, window (§10.4.1.1) पर सेट है।

  2. एवल कोड दर्ज करना

    • … एक सीधी कॉल करके eval ()

      यह बंधन अपरिवर्तित छोड़ दिया गया है; यह कॉलिंग निष्पादन संदर्भ (§10.4.2 (2) (ए)) के इस बाइंडिंग के समान मूल्य है।

    • … यदि नहीं तो सीधे कॉल करने के लिए eval ()

      यह बाइंडिंग वैश्विक ऑब्जेक्ट पर सेट है जैसे प्रारंभिक वैश्विक निष्पादन संदर्भ (§10.4.2 (1)) में निष्पादित हो रहा है।

    §15.1.2.1.1 परिभाषित करता है कि क्या एक सीधे कॉल eval () है मूल रूप से, eval(...) एक प्रत्यक्ष कॉल है, जबकि कुछ (0, eval)(...) या var indirectEval = eval; indirectEval(...); var indirectEval = eval; indirectEval(...); eval () को एक अप्रत्यक्ष कॉल है चकज का जवाब देखें (1, इवल ) ('यह') बनाम बनाल ('यह') जावास्क्रिप्ट में? और दिमित्री सोशनीकोव द्वारा इस ब्लॉग पोस्ट के लिए जब आप अप्रत्यक्ष eval () कॉल का उपयोग कर सकते हैं

  3. फ़ंक्शन कोड दर्ज करना

    फ़ंक्शन बुलाते समय यह तब होता है। अगर किसी ऑब्जेक्ट पर फ़ंक्शन को ऑब्जेक्ट कहा जाता है, जैसे obj.myMethod() या समतुल्य obj["myMethod"]() , तो ऑब्जेक्ट पर ऑब्जेक्ट ( obj उदाहरण में; §13.2.1) सेट है। अधिकांश अन्य मामलों में, बायबिंग वैश्विक वस्तु (§10.4.3) पर सेट है।

    "अधिकांश अन्य मामलों में" लिखने का कारण यह है कि इसमें आठ ECMAScript 5 बिल्ट-इन फ़ंक्शन हैं जो द्विबंधाओं को तर्क सूची में निर्दिष्ट करने की अनुमति देते हैं। ये विशेष फ़ंक्शंस तथाकथित यह एआरजी लेते हैं जो फंक्शन (§10.4.3) को बुलाते समय इसबैंडिंग हो जाता है।

    ये विशेष निर्मित फ़ंक्शंस हैं:

    • Function.prototype.apply( thisArg, argArray )
    • Function.prototype.call( thisArg [ , arg1 [ , arg2, ... ] ] )
    • Function.prototype.bind( thisArg [ , arg1 [ , arg2, ... ] ] )
    • Array.prototype.every( callbackfn [ , thisArg ] )
    • Array.prototype.some( callbackfn [ , thisArg ] )
    • Array.prototype.forEach( callbackfn [ , thisArg ] )
    • Array.prototype.map( callbackfn [ , thisArg ] )
    • Array.prototype.filter( callbackfn [ , thisArg ] )

    फ़ंक्शन.प्रोटोटाइप फ़ंक्शन के मामले में, उन्हें फ़ंक्शन ऑब्जेक्ट पर बुलाया जाता है, लेकिन फ़ंक्शन ऑब्जेक्ट पर यह बांडिंग सेट करने के बजाय , इसबैडिंग thisArg पर सेट है।

    Array.prototype फ़ंक्शंस के मामले में, दिए गए कॉलबैक को निष्पादन संदर्भ में कहा जाता है जहां यह बीडिंग इस एआरजी पर सेट है यदि आपूर्ति की जाती है; अन्यथा, वैश्विक वस्तु के लिए

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

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

 function doWork(callbackfn, thisArg) { //... if (callbackfn != null) callbackfn.call(thisArg); } 

संपादित करें:

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

 function MyType() { this.someData = "a string"; } var instance = new MyType(); // Kind of like the following, but there are more steps involved: // var instance = {}; // MyType.call(instance); 

क्विज: बस मस्ती के लिए, निम्नलिखित उदाहरणों के साथ अपनी समझ का परीक्षण करें।

उत्तर प्रकट करने के लिए, हल्के पीले बक्से पर माउस।

  1. लाइन ए पर this का मूल्य क्या है? क्यूं कर?

     <script type="text/javascript"> if (true) { // Line A } </script> 

    window

    लाइन ए का प्रारंभिक वैश्विक निष्पादन संदर्भ में मूल्यांकन किया गया है।

  2. ओबीजेस्टैटिक फंक्शन () को निष्पादित this पर लाइन बी में this क्या मान है? क्यूं कर?

     <script type="text/javascript"> var obj = { someData: "a string" }; function myFun() { // Line B } obj.staticFunction = myFun; obj.staticFunction(); </script> 

    obj

    ऑब्जेक्ट पर फ़ंक्शन बुलाते समय, बॉबिंग ऑब्जेक्ट पर सेट है।

  3. लाइन सी पर this का मूल्य क्या है? क्यूं कर?

     <script type="text/javascript"> var obj = { myMethod : function () { // Line C } }; var myFun = obj.myMethod; myFun(); </script> 

    window

    इस उदाहरण में, जावास्क्रिप्ट दुभाषिया फ़ंक्शन कोड में प्रवेश करता है, लेकिन क्योंकि myFun / obj.myMethod किसी ऑब्जेक्ट पर नहीं बुलाया जाता है, यह बाइंडिंग window सेट है।

    यह पायथन से भिन्न है, जिसमें एक विधि ( obj.myMethod ) तक पहुँचने से एक बाध्य विधि ऑब्जेक्ट बनाता है।

  4. लाइन डी पर this का मूल्य क्या है? क्यूं कर?

     <script type="text/javascript"> function myFun() { // Line D } var obj = { myMethod : function () { eval("myFun()"); } }; obj.myMethod(); </script> 

    window

    यह एक मुश्किल था। Eval कोड का मूल्यांकन करते समय, this obj । हालांकि, eval कोड में, myFun को किसी ऑब्जेक्ट पर नहीं बुलाया जाता है, इसलिए कॉल करने के लिए यह बंडिंग window सेट है।

  5. लाइन ई पर this का मूल्य क्या है?

     <script type="text/javascript"> function myFun() { // Line E } var obj = { someData: "a string" }; myFun.call(obj); </script> 

    obj

    लाइन myFun.call(obj); विशेष निर्मित फ़ंक्शन Function.prototype.call () को लागू कर रहा है, जो यह एआरजी को पहली तर्क के रूप में स्वीकार करता है।

this कीवर्ड अन्य भाषा की तुलना में जावास्क्रिप्ट में अलग ढंग से व्यवहार करता है। ऑब्जेक्ट ओरिएंटेड भाषाओं में, this कीवर्ड वर्ग के वर्तमान उदाहरण को दर्शाता है। जावास्क्रिप्ट में इसका मूल्य ज्यादातर समारोह ( context.function() ) के आविष्कार संदर्भ द्वारा निर्धारित किया जाता है और जहां इसे कहा जाता है।

1. जब वैश्विक संदर्भ में उपयोग किया जाता है

जब आप इसे वैश्विक संदर्भ में उपयोग this , तो वह वैश्विक ऑब्जेक्ट (ब्राउज़र में window )

 document.write(this); //[object Window] 

जब आप वैश्विक संदर्भ में निर्धारित फ़ंक्शन के अंदर इसका उपयोग this , तो this अभी भी वैश्विक ऑब्जेक्ट के लिए बाध्य है क्योंकि फ़ंक्शन वास्तव में वैश्विक संदर्भ का एक तरीका बना है।

 function f1() { return this; } document.write(f1()); //[object Window] 

f1 ऊपर वैश्विक वस्तु का एक तरीका बना दिया गया है। इस प्रकार हम इसे window ऑब्जेक्ट पर निम्नानुसार कॉल भी कर सकते हैं:

 function f() { return this; } document.write(window.f()); //[object Window] 

2. जब ऑब्जेक्ट विधि के अंदर उपयोग किया जाता है

जब आप किसी वस्तु विधि के अंदर this कीवर्ड का उपयोग this , तो this "तत्काल" संलग्न ऑब्जेक्ट के लिए बाध्य है।

 var obj = { name: "obj", f: function () { return this + ":" + this.name; } }; document.write(obj.f()); //[object Object]:obj 

इसके बाद मैंने शब्द को तत्काल दोहरे उद्धरण में डाल दिया है। यह बात करने के लिए है कि यदि आप ऑब्जेक्ट को किसी दूसरे ऑब्जेक्ट के अंदर ले जाएं, तो this तत्काल पैरेंट के लिए बाध्य है।

 var obj = { name: "obj1", nestedobj: { name:"nestedobj", f: function () { return this + ":" + this.name; } } } document.write(obj.nestedobj.f()); //[object Object]:nestedobj 

यहां तक ​​कि अगर आप एक विधि के रूप में ऑब्जेक्ट को स्पष्ट रूप से फ़ंक्शन जोड़ते हैं, तो यह अभी भी उपरोक्त नियमों का पालन करता है, यह अभी भी तात्कालिक पैरेंट ऑब्जेक्ट को इंगित करता है।

 var obj1 = { name: "obj1", } function returnName() { return this + ":" + this.name; } obj1.f = returnName; //add method to object document.write(obj1.f()); //[object Object]:obj1 

3. संदर्भ-कम फ़ंक्शन का उपयोग करते समय

जब आप this फ़ंक्शन के अंदर किसी भी संदर्भ (यानी किसी ऑब्जेक्ट पर) के बिना लागू होते हैं, तो यह वैश्विक ऑब्जेक्ट (ब्राउज़र में window ) (यहां तक ​​कि फ़ंक्शन ऑब्जेक्ट के अंदर परिभाषित किया गया है) के लिए बाध्य है।

 var context = "global"; var obj = { context: "object", method: function () { function f() { var context = "function"; return this + ":" +this.context; }; return f(); //invoked without context } }; document.write(obj.method()); //[object Window]:global 

कार्यों के साथ सभी को कोशिश कर रहा है

हम कार्य के साथ अंक के ऊपर भी कोशिश कर सकते हैं हालांकि कुछ मतभेद हैं

  • इसके बाद हम ऑब्जेक्ट सिक्रेटिक नोटेशन के जरिए ऑब्जेक्ट्स को जोड़ते हैं। हम this का उपयोग करके सदस्यों को कार्य में जोड़ सकते हैं। उन्हें निर्दिष्ट करने के लिए
  • ऑब्जेक्ट आभासी नोटेशन वस्तु का एक उदाहरण बनाता है जिसे हम तुरंत उपयोग कर सकते हैं फ़ंक्शन के साथ हमें new ऑपरेटर का उपयोग करके इसके उदाहरण को पहले बनाने की आवश्यकता हो सकती है।
  • किसी वस्तु के वास्तविक दृष्टिकोण में, हम सदस्यों को स्पष्ट रूप से डॉट ऑपरेटर के माध्यम से पहले से परिभाषित ऑब्जेक्ट जोड़ सकते हैं। यह केवल विशिष्ट उदाहरण में जोड़ा जाता है हालांकि मैंने फ़ंक्शन प्रोटोटाइप में वैरिएबल जोड़ दिया है ताकि फ़ंक्शन के सभी इंस्टेंसेस में यह प्रतिबिंबित हो।

नीचे मैंने ऑब्जेक्ट और इसके साथ ऊपर की सभी चीज़ों को करने की कोशिश की, लेकिन ऑब्जेक्ट को सीधे लिखने के बजाय फ़ंक्शन बनाने से पहले

 /********************************************************************* 1. When you add variable to the function using this keyword, it gets added to the function prototype, thus allowing all function instances to have their own copy of the variables added. *********************************************************************/ function functionDef() { this.name = "ObjDefinition"; this.getName = function(){ return this+":"+this.name; } } obj1 = new functionDef(); document.write(obj1.getName() + "<br />"); //[object Object]:ObjDefinition /********************************************************************* 2. Members explicitly added to the function protorype also behave as above: all function instances have their own copy of the variable added. *********************************************************************/ functionDef.prototype.version = 1; functionDef.prototype.getVersion = function(){ return "v"+this.version; //see how this.version refers to the //version variable added through //prototype } document.write(obj1.getVersion() + "<br />"); //v1 /********************************************************************* 3. Illustrating that the function variables added by both above ways have their own copies across function instances *********************************************************************/ functionDef.prototype.incrementVersion = function(){ this.version = this.version + 1; } var obj2 = new functionDef(); document.write(obj2.getVersion() + "<br />"); //v1 obj2.incrementVersion(); //incrementing version in obj2 //does not affect obj1 version document.write(obj2.getVersion() + "<br />"); //v2 document.write(obj1.getVersion() + "<br />"); //v1 /********************************************************************* 4. `this` keyword refers to the immediate parent object. If you nest the object through function prototype, then `this` inside object refers to the nested object not the function instance *********************************************************************/ functionDef.prototype.nestedObj = { name: 'nestedObj', getName1 : function(){ return this+":"+this.name; } }; document.write(obj2.nestedObj.getName1() + "<br />"); //[object Object]:nestedObj /********************************************************************* 5. If the method is on an object's prototype chain, `this` refers to the object the method was called on, as if the method was on the object. *********************************************************************/ var ProtoObj = { fun: function () { return this.a } }; var obj3 = Object.create(ProtoObj); //creating an object setting ProtoObj //as its prototype obj3.a = 999; //adding instance member to obj3 document.write(obj3.fun()+"<br />");//999 //calling obj3.fun() makes //ProtoObj.fun() to access obj3.a as //if fun() is defined on obj3 

4. जब कन्स्ट्रक्टर फ़ंक्शन में उपयोग किया जाता है

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

 var myname = "global context"; function SimpleFun() { this.myname = "simple function"; } var obj1 = new SimpleFun(); //adds myname to obj1 //1. `new` causes `this` inside the SimpleFun() to point to the // object being constructed thus adding any member // created inside SimipleFun() using this.membername to the // object being constructed //2. And by default `new` makes function to return newly // constructed object if no explicit return value is specified document.write(obj1.myname); //simple function 

5. प्रोटोटाइप श्रृंखला पर परिभाषित समारोह के अंदर उपयोग किया जाता है

यदि विधि किसी ऑब्जेक्ट के प्रोटोटाइप श्रृंखला पर है, तो this तरह की विधि के अंदर विधि को संदर्भित किया गया ऑब्जेक्ट को संदर्भित करता है, जैसे कि ऑब्जेक्ट पर विधि परिभाषित की जाती है।

 var ProtoObj = { fun: function () { return this.a; } }; //Object.create() creates object with ProtoObj as its //prototype and assigns it to obj3, thus making fun() //to be the method on its prototype chain var obj3 = Object.create(ProtoObj); obj3.a = 999; document.write(obj3.fun()); //999 //Notice that fun() is defined on obj3's prototype but //`this.a` inside fun() retrieves obj3.a 

6. कॉल के अंदर (), () और बाध्य () फ़ंक्शंस लागू करें

  • इन सभी विधियों को Function.prototype पर परिभाषित किया गया है।
  • ये विधियां एक बार एक फ़ंक्शन लिखने की अनुमति देती हैं और इसे अलग-अलग संदर्भ में लागू कर सकती हैं। दूसरे शब्दों में, वे this के मूल्य को निर्दिष्ट करने की अनुमति देते हैं, जिसका उपयोग फ़ंक्शन निष्पादित किया जा रहा है। वे मूल फ़ंक्शन को पारित करने के लिए किसी भी पैरामीटर भी लेते हैं, जब इसे लागू किया जाता है।
  • fun.apply(obj1 [, argsArray]) अंदर के मूल्य के रूप में obj1 को सेट करता fun() और fun() को तर्क देता है fun() argsArray तत्वों को उसके तर्क के रूप में fun()
  • fun.call(obj1 [, arg1 [, arg2 [,arg3 [, ...]]]])fun() अंदर obj1 को मान के रूप में सेट करता है और fun() को कहता fun() arg1, arg2, arg3, ... गुजर रहा है arg1, arg2, arg3, ... इसके तर्क के रूप में
  • fun.bind(obj1 [, arg1 [, arg2 [,arg3 [, ...]]]])fun obj1 और obj1 मानकों के साथ fun समारोह के संदर्भ में, पैरामीटर निर्दिष्ट पैरामीटर के लिए बाध्य करता है arg1, arg2, arg3,...
  • अब तक apply , call और bind बीच अंतर स्पष्ट हो गया होगा। apply करने के लिए तर्कों को सरणी-जैसे ऑब्जेक्ट के रूप में कार्य apply अनुमति देता है, अर्थात् एक संख्यात्मक length संपत्ति और इसी गैर-नकारात्मक पूर्णांक गुणों के साथ एक वस्तु। जबकि call सीधे फ़ंक्शन के तर्कों को निर्दिष्ट करने की अनुमति देता है दोनों apply और call तुरंत निर्दिष्ट संदर्भ में और विशिष्ट तर्कों के साथ समारोह का आह्वान करते हैं। दूसरी ओर, bind बस फ़ंक्शन को निर्दिष्ट मूल्य और तर्कों के लिए बाध्य करता है। हम इस फ़ंक्शन को संदर्भित करके इसे एक चर में निर्दिष्ट कर सकते हैं और बाद में हम इसे किसी भी समय कॉल कर सकते हैं।
 function add(inc1, inc2) { return this.a + inc1 + inc2; } var o = { a : 4 }; document.write(add.call(o, 5, 6)+"<br />"); //15 //above add.call(o,5,6) sets `this` inside //add() to `o` and calls add() resulting: // this.a + inc1 + inc2 = // `oa` ie 4 + 5 + 6 = 15 document.write(add.apply(o, [5, 6]) + "<br />"); //15 // `oa` ie 4 + 5 + 6 = 15 var g = add.bind(o, 5, 6); //g: `oa` ie 4 + 5 + 6 document.write(g()+"<br />"); //15 var h = add.bind(o, 5); //h: `oa` ie 4 + 5 + ? document.write(h(6) + "<br />"); //15 // 4 + 5 + 6 = 15 document.write(h() + "<br />"); //NaN //no parameter is passed to h() //thus inc2 inside add() is `undefined` //4 + 5 + undefined = NaN</code> 

7. this अंदर घटना हैंडलर

  • जब आप किसी तत्व के ईवेंट हैंडलर्स को सीधे फ़ंक्शन सौंपते हैं, तो this सीधे इवेंट हैंडलिंग फ़ंक्शन का उपयोग इसी तत्व को दर्शाता है। इस तरह के प्रत्यक्ष समारोह असाइनमेंट addeventListener विधि का उपयोग करके या onclick जैसी पारंपरिक इवेंट पंजीकरण विधियों के माध्यम से किया जा सकता है।
  • इसी प्रकार, जब आप सीधे इवेंट संपत्ति (जैसे <button onclick="...this..." > ) के अंदर का उपयोग this हैं, तो यह तत्व को संदर्भित करता है।
  • हालांकि this परोक्ष रूप से अन्य फ़ंक्शन के माध्यम से उपयोग किया जाता है जिसे इवेंट हैंडलिंग फ़ंक्शन या इवेंट प्रॉपर्टी के अंदर कहा जाता है, वह वैश्विक ऑब्जेक्ट window हल करती है।
  • वही उपरोक्त व्यवहार प्राप्त होता है जब हम फ़ंक्शन को ईवेंट हैंडलर को माइक्रोसॉफ्ट के इवेंट पंजीकरण मॉडल विधि attachEvent का उपयोग करते हुए संलग्न करते हैं। ईवेंट हैंडलर को फ़ंक्शन देने के बजाय (और इस प्रकार तत्व की फ़ंक्शन पद्धति बनाते हुए), यह ईवेंट पर समारोह को कॉल करता है (प्रभावी रूप से इसे वैश्विक संदर्भ में बुलाता है)

मैं बेहतर JSFiddle में यह कोशिश करने की सलाह देते हैं

 <script> function clickedMe() { alert(this + " : " + this.tagName + " : " + this.id); } document.getElementById("button1").addEventListener("click", clickedMe, false); document.getElementById("button2").onclick = clickedMe; document.getElementById("button5").attachEvent('onclick', clickedMe); </script> <h3>Using `this` "directly" inside event handler or event property</h3> <button id="button1">click() "assigned" using addEventListner() </button><br /> <button id="button2">click() "assigned" using click() </button><br /> <button id="button3" onclick="alert(this+ ' : ' + this.tagName + ' : ' + this.id);">used `this` directly in click event property</button> <h3>Using `this` "indirectly" inside event handler or event property</h3> <button onclick="alert((function(){return this + ' : ' + this.tagName + ' : ' + this.id;})());">`this` used indirectly, inside function <br /> defined & called inside event property</button><br /> <button id="button4" onclick="clickedMe()">`this` used indirectly, inside function <br /> called inside event property</button> <br /> IE only: <button id="button5">click() "attached" using attachEvent() </button> 

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

जब लोग अनाम बंद करने वाले कार्यों के अंदर "इस" का उपयोग करने की कोशिश करते हैं, तो अधिकांश लोग भ्रमित होते हैं:

 (कार्य (मान) {
     this.value = मान;
     $ ( '। कुछ-तत्व')। प्रत्येक (समारोह (ईएलटी) {
         elt.innerHTML = this.value;  // उह ओह!!  संभवतः अपरिभाषित
     });
 }) (2);

तो यहां, प्रत्येक () के अंदर, "यह" "मूल्य" को नहीं पकड़ता है जिसे आप उम्मीद करते हैं (से

  this.value = मान; 

इसके ऊपर)। इसलिए, इस (कोई यमक इरादा) समस्या को पाने के लिए, एक डेवलपर:

 (कार्य (मान) {
     var आत्म = यह;  // छोटा सा बदलाव
     self.value = मान;
     $ ( '। कुछ-तत्व')। प्रत्येक (समारोह (ईएलटी) {
         elt.innerHTML = self.value;  // प्यू !!  == 2 
     });
 }) (2);

कोशिश करके देखो; आप प्रोग्रामिंग के इस पैटर्न को पसंद करना शुरू करेंगे

जावास्क्रिप्ट this

साधारण फ़ंक्शन अभिविन्यास

निम्नलिखित फ़ंक्शन पर विचार करें:

 function foo() { console.log("bar"); console.log(this); } foo(); // calling the function 

ध्यान दें कि हम इसे सामान्य मोड में चल रहे हैं, यानी सख्त मोड का उपयोग नहीं किया जाता है।

जब किसी ब्राउज़र में चलाया जाता है, तो इसका मान window रूप में लॉग होगा। इसका कारण यह है कि window वेब ब्राउजर के दायरे में वैश्विक वैरिएबल है।

यदि आप नोड। जेएस जैसे वातावरण में कोड का एक ही भाग चलाते हैं, तो this आपके ऐप में वैश्विक चर का संदर्भ देगा।

अब अगर हम इसे सख्त मोड में "use strict"; कथन जोड़कर चलाते हैं "use strict"; फ़ंक्शन घोषणा की शुरुआत करने के लिए, this वैश्विक वातावरणों में से किसी एक या वैश्विक चर को संदर्भित नहीं करेगा। यह कड़े मोड में भ्रम से बचने के लिए किया जाता है। this होगा, इस मामले में सिर्फ undefined लॉग इन करें, क्योंकि वह यही है, यह परिभाषित नहीं है।

निम्नलिखित मामलों में, हम देखेंगे कि this के मूल्य को कैसे हेरफेर करना है।

ऑब्जेक्ट पर फ़ंक्शन कॉल करना

ऐसा करने के लिए अलग-अलग तरीके हैं यदि आपने जावास्क्रिप्ट में मूल और मूल भाषा के लिए हर भाषा का नाम दिया है, तो आपको पहले से ही पता होना चाहिए कि उस स्थिति में this चर Object को संदर्भित करता है जिस पर आपने उस फ़ंक्शन को नोट किया है (ध्यान दें कि जावास्क्रिप्ट में, सब कुछ एक Object , जिसमें Array एस और Function एस)। उदाहरण के लिए निम्न कोड लें

 var myObj = {key: "Obj"}; myObj.logThis = function () { // I am a method console.log(this); } myObj.logThis(); // myObj is logged 

यदि किसी Object में एक संपत्ति है जो एक Function रखती है, संपत्ति को एक विधि कहा जाता है। यह विधि, जिसे बुलाया जाता है, हमेशा this वैरिएबल को सेट Object के साथ Object इसे इसके साथ जुड़ा हुआ है। यह सख्त और गैर-कठोर दोनों तरीकों के लिए सही है

ध्यान दें कि यदि किसी विधि को एक अन्य चर में संग्रहीत किया गया है (या फिर, कॉपी किया गया है), तो इसका संदर्भ अब नए चर में संरक्षित नहीं है। उदाहरण के लिए:

 // continuing with the previous code snippet var myVar = myObj.thisMethod; myVar(); // logs either of window/global/undefined based on mode of operation 

अधिक व्यावहारिक परिदृश्य को देखते हुए:

 var el = document.getElementById('idOfEl'); el.addEventListener('click', function() { console.log(this) }); // the function called by addEventListener contains this as the reference to the element // so clicking on our element would log that element itself 

new कीवर्ड

जावास्क्रिप्ट में एक कन्स्ट्रक्टर फ़ंक्शन पर विचार करें:

 function Person (name) { this.name = name; this.sayHello = function () { console.log ("Hello", this); } } var awal = new Person("Awal"); awal.sayHello(); // In `awal.sayHello`, `this` contains the reference to the variable `awal` 

यह कैसे काम करता है? ठीक है, देखते हैं कि जब हम new कीवर्ड का उपयोग करते हैं तो क्या होता है।

  1. फ़ंक्शन को new कीवर्ड के साथ कॉल करने से तुरंत Object ऑफ़ टाइप Object को आरम्भ किया जाएगा
  2. इस Object कन्स्ट्रक्टर को इसके कन्स्ट्रक्टर को Person सेट किया गया है। इसके अलावा, ध्यान दें कि typeof awal केवल Object ही लौटाएगा।
  3. यह नया Object Person.prototype के Person.prototype सौंपा जाएगा। इसका अर्थ यह है कि Person प्रोटोटाइप में किसी भी विधि या संपत्ति को Person के सभी उदाहरणों के लिए उपलब्ध होगा, जिसमें शामिल है awal
  4. फ़ंक्शन Person स्वयं अब आमंत्रित किया जाता है; this नव निर्मित वस्तु awal एक संदर्भ है।

सुंदर स्ट्रॉफ़ावर्ड, एह?

ध्यान दें कि आधिकारिक ECMAScript स्पेक नं, जहां बताता है कि ऐसे प्रकार के फ़ंक्शन वास्तविक constructor फ़ंक्शन हैं। वे सिर्फ सामान्य कार्य हैं, और किसी भी फ़ंक्शन पर new का उपयोग किया जा सकता है। यह सिर्फ इतना है कि हम उन्हें उनसे उपयोग करते हैं, और इसलिए हम उन्हें केवल ऐसे ही कहते हैं।

कार्यों पर कॉलिंग फ़ंक्शन: call और apply

तो हाँ, क्योंकि function एस (और जावा में जावास्क्रिप्ट में प्रथम श्रेणी के चर) Objects हैं, यहां तक ​​कि फ़ंक्शन के तरीकों में भी हैं … अच्छा, उनके सोचे गए कार्य

सभी फ़ंक्शंस वैश्विक Function से Function , और इसके कई दो तरीके call और apply , और दोनों का उपयोग उस फ़ंक्शन में उस मूल्य को हेरफेर करने के लिए किया जा सकता है जिस पर उन्हें कहा जाता है।

 function foo () { console.log (this, arguments); } var thisArg = {myObj: "is cool"}; foo.call(thisArg, 1, 2, 3); 

यह call का उपयोग करने का एक विशिष्ट उदाहरण है। यह मूल रूप से पहले पैरामीटर लेता है और this समारोह के संदर्भ में foo में सेट करता है। call करने के लिए पारित किए गए सभी अन्य पैरामीटर फ़ंक्शन foo को तर्क के रूप में पास किए जाते हैं।
तो उपरोक्त कोड {myObj: "is cool"}, [1, 2, 3] लॉग करेगा। किसी भी समारोह में इसके मूल्य को बदलने के लिए बहुत अच्छा तरीका है।

apply लगभग समान है क्योंकि call स्वीकार करते हैं कि यह केवल दो मापदंडों को लेता है: thisArg और एक सरणी जिसमें फ़ंक्शन के पास होने वाले तर्क शामिल हैं इसलिए ऊपर की call कॉल को इस तरह apply करने के apply अनुवाद किया जा सकता है:

 foo.apply(thisArg, [1,2,3]) 

ध्यान दें कि call और apply हैं, this सेट के मान को डॉट मैथर्ड इनवोकेशन द्वारा ओवरराइड कर सकते हैं जो हमने दूसरे बुलेट में चर्चा की थी। काफी सरल 🙂

प्रस्तुत करना …. bind !

bind call एक भाई है और apply । यह जावास्क्रिप्ट में वैश्विक Function कन्स्ट्रक्टर से सभी कार्यों के द्वारा विरासत में मिली एक विधि है। bind और call / apply बीच का अंतर यह है कि call और apply दोनों वास्तव में फ़ंक्शन को आमंत्रित करेंगे। bind , दूसरी ओर, इस thisArg और arguments पूर्व-सेट के साथ एक नया फ़ंक्शन देता है। इसे बेहतर ढंग से समझने के लिए एक उदाहरण लें:

 function foo (a, b) { console.log (this, arguments); } var thisArg = {myObj: "even more cool now"}; var bound = foo.bind(thisArg, 1, 2); console.log (typeof bound); // logs `function` console.log (bound); /* logs `function () { native code }` */ bound(); // calling the function returned by `.bind` // logs `{myObj: "even more cool now"}, [1, 2]` 

तीनों के बीच का अंतर देखें? यह सूक्ष्म है, लेकिन ये अलग तरह से उपयोग किया जाता है। call और apply , bind भी this सेट के मान को डॉट-मैनेजमेंट घोषित करेगा।

यह भी ध्यान रखें कि इन तीन कार्यों में से कोई भी मूल फ़ंक्शन में कोई बदलाव नहीं करता है। call और apply call नए सिरे से किए गए कार्यों से मूल्य लौटाएंगे, जबकि bind ताजा निर्माण कार्य वापस लौटाएगा, जिसे कॉल करने के लिए तैयार होगा।

अतिरिक्त सामान, इस कॉपी करें

कभी-कभी, आप this तथ्य को पसंद नहीं करते हैं कि this क्षेत्र के साथ बदलता है, विशेष रूप से नेस्टेड क्षेत्र निम्नलिखित उदाहरण पर एक नज़र डालें

 var myObj = { hello: function () { return "world" }, myMethod: function () { // copy this, variable names are case-sensitive var that = this; // callbacks ftw \o/ foo.bar("args", function () { // I want to call `hello` here this.hello(); // error // but `this` references to `foo` damn! // oh wait we have a backup \o/ that.hello(); // "world" }); } }; 

उपरोक्त कोड में, हम देखते हैं कि इस के मान नेस्टेड क्षेत्र के साथ बदल दिया है, लेकिन हम मूल गुंजाइश से this का मान चाहते थे। इसलिए हमने इसे 'प्रतिलिपि' किया और इसके बदले प्रतिलिपि का इस्तेमाल किया। चालाक, हे?

सूचकांक:

  1. क्या this में डिफ़ॉल्ट रूप से आयोजित किया जाता है?
  2. यदि हम फ़ंक्शन को ऑब्जेक्ट-डॉट नॉटेशन के साथ एक विधि के रूप में कहते हैं?
  3. यदि हम new कीवर्ड का उपयोग करते हैं तो क्या होगा?
  4. हम this call साथ हेरफेर कैसे करते call और apply ?
  5. bind का उपयोग करना
  6. नेस्टेड-स्कोप के मुद्दों को हल करने के लिए this कॉपी करना

Since this thread has bumped up, I have compiled few points for readers new to this topic.

How is the value of this determined?

We use this similar to the way we use pronouns in natural languages like English: “John is running fast because he is trying to catch the train.” Instead we could have written “… John is trying to catch the train”.

 var person = { firstName: "Penelope", lastName: "Barrymore", fullName: function () { // We use "this" just as in the sentence above: console.log(this.firstName + " " + this.lastName); // We could have also written: console.log(person.firstName + " " + person.lastName); } } 

this is not assigned a value until an object invokes the function where it is defined. In the global scope, all global variables and functions are defined on the window object. Therefore, this in a global function refers to (and has the value of) the global window object.

When use strict , this in global and in anonymous functions that are not bound to any object holds a value of undefined .

The this keyword is most misunderstood when: 1) we borrow a method that uses this , 2) we assign a method that uses this to a variable, 3) a function that uses this is passed as a callback function, and 4) this is used inside a closure — an inner function. (2)

table

What holds the future

Defined in ECMA Script 6 , arrow-functions adopt the this binding from the enclosing (function or global) scope.

 function foo() { // return an arrow function return (a) => { // `this` here is lexically inherited from `foo()` console.log(this.a); }; } var obj1 = { a: 2 }; var obj2 = { a: 3 }; var bar = foo.call(obj1); bar.call( obj2 ); // 2, not 3! 

While arrow-functions provide an alternative to using bind() , it's important to note that they essentially are disabling the traditional this mechanism in favor of more widely understood lexical scoping. (1)


References:

  1. this & Object Prototypes , by Kyle Simpson. © 2014 Getify Solutions.
  2. javascriptissexy.com – http://goo.gl/pvl0GX
  3. Angus Croll – http://goo.gl/Z2RacU

this in Javascript always refers to the 'owner' of the function that is being executed .

If no explicit owner is defined, then the top most owner, the window object, is referenced.

So if I did

 function someKindOfFunction() { this.style = 'foo'; } 

element.onclick = someKindOfFunction;

this would refer to the element object. But be careful, a lot of people make this mistake

<element onclick="someKindOfFunction()">

In the latter case, you merely reference the function, not hand it over to the element. Therefor, this will refer to the window object.

Here is one good source of this in JavaScript .

Here is the summary:

  • global this

    In a browser, at the global scope, this is the window object

     <script type="text/javascript"> console.log(this === window); // true var foo = "bar"; console.log(this.foo); // "bar" console.log(window.foo); // "bar" 

    In node using the repl, this is the top namespace. You can refer to it as global .

     >this { ArrayBuffer: [Function: ArrayBuffer], Int8Array: { [Function: Int8Array] BYTES_PER_ELEMENT: 1 }, Uint8Array: { [Function: Uint8Array] BYTES_PER_ELEMENT: 1 }, ... >global === this true 

    In node executing from a script, this at the global scope starts as an empty object. It is not the same as global

     \\test.js console.log(this); \\ {} console.log(this === global); \\ fasle 
  • function this

Except in the case of DOM event handlers or when a thisArg is provided (see further down), both in node and in a browser using this in a function that is not called with new references the global scope…

 <script type="text/javascript"> foo = "bar"; function testThis() { this.foo = "foo"; } console.log(this.foo); //logs "bar" testThis(); console.log(this.foo); //logs "foo" </script> 

If you use use strict; , in which case this will be undefined

 <script type="text/javascript"> foo = "bar"; function testThis() { "use strict"; this.foo = "foo"; } console.log(this.foo); //logs "bar" testThis(); //Uncaught TypeError: Cannot set property 'foo' of undefined </script> 

If you call a function with new the this will be a new context, it will not reference the global this .

 <script type="text/javascript"> foo = "bar"; function testThis() { this.foo = "foo"; } console.log(this.foo); //logs "bar" new testThis(); console.log(this.foo); //logs "bar" console.log(new testThis().foo); //logs "foo" </script> 
  • prototype this

Functions you create become function objects. They automatically get a special prototype property, which is something you can assign values to. When you create an instance by calling your function with new you get access to the values you assigned to the prototype property. You access those values using this .

 function Thing() { console.log(this.foo); } Thing.prototype.foo = "bar"; var thing = new Thing(); //logs "bar" console.log(thing.foo); //logs "bar" 

It is usually a mistake to assign arrays or objects on the prototype . If you want instances to each have their own arrays, create them in the function, not the prototype.

 function Thing() { this.things = []; } var thing1 = new Thing(); var thing2 = new Thing(); thing1.things.push("foo"); console.log(thing1.things); //logs ["foo"] console.log(thing2.things); //logs [] 
  • object this

You can use this in any function on an object to refer to other properties on that object. This is not the same as an instance created with new .

 var obj = { foo: "bar", logFoo: function () { console.log(this.foo); } }; obj.logFoo(); //logs "bar" 
  • DOM event this

In an HTML DOM event handler, this is always a reference to the DOM element the event was attached to

 function Listener() { document.getElementById("foo").addEventListener("click", this.handleClick); } Listener.prototype.handleClick = function (event) { console.log(this); //logs "<div id="foo"></div>" } var listener = new Listener(); document.getElementById("foo").click(); 

Unless you bind the context

 function Listener() { document.getElementById("foo").addEventListener("click", this.handleClick.bind(this)); } Listener.prototype.handleClick = function (event) { console.log(this); //logs Listener {handleClick: function} } var listener = new Listener(); document.getElementById("foo").click(); 
  • HTML this

Inside HTML attributes in which you can put JavaScript, this is a reference to the element.

 <div id="foo" onclick="console.log(this);"></div> <script type="text/javascript"> document.getElementById("foo").click(); //logs <div id="foo"... </script> 
  • eval this

You can use eval to access this .

 function Thing () { } Thing.prototype.foo = "bar"; Thing.prototype.logFoo = function () { eval("console.log(this.foo)"); //logs "bar" } var thing = new Thing(); thing.logFoo(); 
  • with this

You can use with to add this to the current scope to read and write to values on this without referring to this explicitly.

 function Thing () { } Thing.prototype.foo = "bar"; Thing.prototype.logFoo = function () { with (this) { console.log(foo); foo = "foo"; } } var thing = new Thing(); thing.logFoo(); // logs "bar" console.log(thing.foo); // logs "foo" 
  • jQuery this

the jQuery will in many places have this refer to a DOM element.

 <div class="foo bar1"></div> <div class="foo bar2"></div> <script type="text/javascript"> $(".foo").each(function () { console.log(this); //logs <div class="foo... }); $(".foo").on("click", function () { console.log(this); //logs <div class="foo... }); $(".foo").each(function () { this.click(); }); </script> 

Every function execution context in javascript has a scope context this parameter that is set by:

  1. How the function is called (including as an object method, use of call and apply , use of new )
  2. Use of bind
  3. Lexically for arrow functions (they adopt the this of their outer execution context)

Whatever that scope context is, is referenced by "this".

You can change that set the value of this scope context using func.call , func.apply or func.bind .

By default, and what confuses most beginners, when a callback listener is called after an event is raised on a DOM element, the scope context this value of the function is the DOM element.

jQuery makes this trivial to change with jQuery.proxy.

Daniel, awesome explanation! A couple of words on this and good list of this execution context pointer in case of event handlers.

In two words, this in JavaScript points the object from whom (or from whose execution context) the current function was run and it's always read-only, you can't set it anyway (such an attempt will end up with 'Invalid left-hand side in assignment' message.

For event handlers: inline event handlers, such as <element onclick="foo"> , override any other handlers attached earlier and before, so be careful and it's better to stay off of inline event delegation at all. And thanks to Zara Alaverdyan who inspired me to this list of examples through a dissenting debate 🙂

  • el.onclick = foo; // in the foo - obj
  • el.onclick = function () {this.style.color = '#fff';} // obj
  • el.onclick = function() {doSomething();} // In the doSomething - Window
  • el.addEventListener('click',foo,false) // in the foo - obj
  • el.attachEvent('onclick, function () { // this }') // window, all the compliance to IE :)
  • <button onclick="this.style.color = '#fff';"> // obj
  • <button onclick="foo"> // In the foo - window, but you can <button onclick="foo(this)">

It is difficult to get a good grasp of JS, or write more than anything trivial in it, if you don't understand it thoroughly. You cannot just afford to take a quick dip 🙂 I think the best way to get started with JS is to first watch these video lectures by Douglas Crockford – http://yuiblog.com/crockford/ , which covers this and that, and everything else about JS.

This is the best explanation I've seen. Understand JavaScripts this with Clarity

The this reference ALWAYS refers to (and holds the value of) an object—a singular object—and it is usually used inside a function or a method, although it can be used outside a function in the global scope. Note that when we use strict mode, this holds the value of undefined in global functions and in anonymous functions that are not bound to any object.

There are Four Conditions where this can be confusing:

  1. When we pass a method (that uses this ) as a parameter to be used as a callback function.
  2. Another instance when this is misunderstood is when we use an inner method (a closure). It is important to take note that closures cannot access the outer function's this variable by using the this keyword because the this variable is accessible only by the function itself, not by inner functions.
  3. Using this when a method is assigned to a variable. The this value is bound to another object, if we assign a method that uses this to a variable
  4. Using this when using bind, apply, and call methods.

He gives code examples, the explanations, and the code fixes which I thought was very helpful.

this is one of the misunderstood concept in JavaScript because it behaves little differently from place to place. Simply, this refers to the "owner" of the function we are currently executing .

this helps to get the current object (aka execution context) we work with. If you understand in which object the current function is getting executed, you can understand easily what current this is

 var val = "window.val" var obj = { val: "obj.val", innerMethod: function () { var val = "obj.val.inner", func = function () { var self = this; return self.val; }; return func; }, outerMethod: function(){ return this.val; } }; //This actually gets executed inside window object console.log(obj.innerMethod()()); //returns window.val //Breakdown in to 2 lines explains this in detail var _inn = obj.innerMethod(); console.log(_inn()); //returns window.val console.log(obj.outerMethod()); //returns obj.val 

Above we create 3 variables with same name 'val'. One in global context, one inside obj and the other inside innerMethod of obj. JavaScript resolves identifiers within a particular context by going up the scope chain from local go global.


Few places where this can be differentiated

Calling a method of a object

 var status = 1; var helper = { status : 2, getStatus: function () { return this.status; } }; var theStatus1 = helper.getStatus(); //line1 console.log(theStatus1); //2 var theStatus2 = helper.getStatus; console.log(theStatus2()); //1 

When line1 is executed, JavaScript establishes an execution context (EC) for the function call, setting this to the object referenced by whatever came before the last "." । so in the last line you can understand that a() was executed in the global context which is the window .

With Constructor

this can be used to refer to the object being created

 function Person(name){ this.personName = name; this.sayHello = function(){ return "Hello " + this.personName; } } var person1 = new Person('Scott'); console.log(person1.sayHello()); //Hello Scott var person2 = new Person('Hugh'); var sayHelloP2 = person2.sayHello; console.log(sayHelloP2()); //Hello undefined 

When new Person() is executed, a completely new object is created. Person is called and its this is set to reference that new object.

Function call

 function testFunc() { this.name = "Name"; this.myCustomAttribute = "Custom Attribute"; return this; } var whatIsThis = testFunc(); console.log(whatIsThis); //window var whatIsThis2 = new testFunc(); console.log(whatIsThis2); //testFunc() / object console.log(window.myCustomAttribute); //Custom Attribute 

If we miss new keyword, whatIsThis referes to the most global context it can find( window )

With event handlers

If the event handler is inline, this refers to global object

 <script type="application/javascript"> function click_handler() { alert(this); // alerts the window object } </script> <button id='thebutton' onclick='click_handler()'>Click me!</button> 

When adding event handler through JavaScript, this refers to DOM element that generated the event.


  • You can also manipulate the context using .apply() .call() and .bind()
  • JQuery proxy is another way you can use to make sure this in a function will be the value you desire. (Check Understanding $.proxy() , jQuery.proxy() usage )
  • What does var that = this means in JavaScript

Probably the most detailed and comprehensive article on this is the following:

Gentle explanation of 'this' keyword in JavaScript

The idea behind this is to understand that the function invocation types have the significant importance on setting this value.


When having troubles identifying this , do not ask yourself:

Where is this taken from ?

but do ask yourself:

How is the function invoked ?

For an arrow function (special case of context transparency) ask yourself:

What value has this where the arrow function is defined ?

This mindset is correct when dealing with this and will save you from headache.

There is a lot of confusion regarding how "this" keyword is interpreted in JavaScript. Hopefully this article will lay all those to rest once and for all. And a lot more. Please read the entire article carefully. Be forewarned that this article is long.

Irrespective of the context in which it is used, "this" always references the "current object" in Javascript. However, what the "current object" is differs according to context . The context may be exactly 1 of the 6 following:

  1. Global (ie Outside all functions)
  2. Inside Direct "Non Bound Function" Call (ie a function that has not been bound by calling functionName.bind )
  3. Inside Indirect "Non Bound Function" Call through functionName.call and functionName.apply
  4. Inside "Bound Function" Call (ie a function that has been bound by calling functionName.bind )
  5. While Object Creation through "new"
  6. Inside Inline DOM event handler

The following describes each of this contexts one by one:

  1. Global Context (ie Outside all functions):

    Outside all functions (ie in global context) the "current object" (and hence the value of "this" ) is always the "window" object for browsers.

  2. Inside Direct "Non Bound Function" Call :

    Inside a Direct "Non Bound Function" Call, the object that invoked the function call becomes the "current object" (and hence the value of "this" ). If a function is called without a explicit current object , the current object is either the "window" object (For Non Strict Mode) or undefined (For Strict Mode) . Any function (or variable) defined in Global Context automatically becomes a property of the "window" object.For eg Suppose function is defined in Global Context as

     function UserDefinedFunction(){ alert(this) } 

    it becomes the property of the window object, as if you have defined it as

     window.UserDefinedFunction=function(){ alert(this) } 

    In "Non Strict Mode", Calling/Invoking this function directly through "UserDefinedFunction()" will automatically call/invoke it as "window.UserDefinedFunction()" making "window" as the "current object" (and hence the value of "this" ) within "UserDefinedFunction" .Invoking this function in "Non Strict Mode" will result in the following

     UserDefinedFunction() // displays [object Window] as it automatically gets invoked as window.UserDefinedFunction() 

    In "Strict Mode", Calling/Invoking the function directly through "UserDefinedFunction()" will "NOT" automatically call/invoke it as "window.UserDefinedFunction()" .Hence the "current object" (and the value of "this" ) within "UserDefinedFunction" shall be undefined . Invoking this function in "Strict Mode" will result in the following

     UserDefinedFunction() // displays undefined 

    However, invoking it explicitly using window object shall result in the following

     window.UserDefinedFunction() // "always displays [object Window] irrespective of mode." 

    Let us look at another example. Please look at the following code

      function UserDefinedFunction() { alert(this.a + "," + this.b + "," + this.c + "," + this.d) } var o1={ a:1, b:2, f:UserDefinedFunction } var o2={ c:3, d:4, f:UserDefinedFunction } o1.f() // Shall display 1,2,undefined,undefined o2.f() // Shall display undefined,undefined,3,4 

    In the above example we see that when "UserDefinedFunction" was invoked through o1 , "this" takes value of o1 and the value of its properties "a" and "b" get displayed. The value of "c" and "d" were shown as undefined as o1 does not define these properties

    Similarly when "UserDefinedFunction" was invoked through o2 , "this" takes value of o2 and the value of its properties "c" and "d" get displayed.The value of "a" and "b" were shown as undefined as o2 does not define these properties.

  3. Inside Indirect "Non Bound Function" Call through functionName.call and functionName.apply :

    When a "Non Bound Function" is called through functionName.call or functionName.apply , the "current object" (and hence the value of "this" ) is set to the value of "this" parameter (first parameter) passed to call/apply . The following code demonstrates the same.

     function UserDefinedFunction() { alert(this.a + "," + this.b + "," + this.c + "," + this.d) } var o1={ a:1, b:2, f:UserDefinedFunction } var o2={ c:3, d:4, f:UserDefinedFunction } UserDefinedFunction.call(o1) // Shall display 1,2,undefined,undefined UserDefinedFunction.apply(o1) // Shall display 1,2,undefined,undefined UserDefinedFunction.call(o2) // Shall display undefined,undefined,3,4 UserDefinedFunction.apply(o2) // Shall display undefined,undefined,3,4 o1.f.call(o2) // Shall display undefined,undefined,3,4 o1.f.apply(o2) // Shall display undefined,undefined,3,4 o2.f.call(o1) // Shall display 1,2,undefined,undefined o2.f.apply(o1) // Shall display 1,2,undefined,undefined 

    The above code clearly shows that the "this" value for any "NON Bound Function" can be altered through call/apply . Also,if the "this" parameter is not explicitly passed to call/apply , "current object" (and hence the value of "this") is set to "window" in Non strict mode and "undefined" in strict mode.

  4. Inside "Bound Function" Call (ie a function that has been bound by calling functionName.bind ):

    A bound function is a function whose "this" value has been fixed. The following code demonstrated how "this" works in case of bound function

     function UserDefinedFunction() { alert(this.a + "," + this.b + "," + this.c + "," + this.d) } var o1={ a:1, b:2, f:UserDefinedFunction, bf:null } var o2={ c:3, d:4, f:UserDefinedFunction, bf:null } var bound1=UserDefinedFunction.bind(o1); // permanantly fixes "this" value of function "bound1" to Object o1 bound1() // Shall display 1,2,undefined,undefined var bound2=UserDefinedFunction.bind(o2); // permanantly fixes "this" value of function "bound2" to Object o2 bound2() // Shall display undefined,undefined,3,4 var bound3=o1.f.bind(o2); // permanantly fixes "this" value of function "bound3" to Object o2 bound3() // Shall display undefined,undefined,3,4 var bound4=o2.f.bind(o1); // permanantly fixes "this" value of function "bound4" to Object o1 bound4() // Shall display 1,2,undefined,undefined o1.bf=UserDefinedFunction.bind(o2) // permanantly fixes "this" value of function "o1.bf" to Object o2 o1.bf() // Shall display undefined,undefined,3,4 o2.bf=UserDefinedFunction.bind(o1) // permanantly fixes "this" value of function "o2.bf" to Object o1 o2.bf() // Shall display 1,2,undefined,undefined bound1.call(o2) // Shall still display 1,2,undefined,undefined. "call" cannot alter the value of "this" for bound function bound1.apply(o2) // Shall still display 1,2,undefined,undefined. "apply" cannot alter the value of "this" for bound function o2.bf.call(o2) // Shall still display 1,2,undefined,undefined. "call" cannot alter the value of "this" for bound function o2.bf.apply(o2) // Shall still display 1,2,undefined,undefined."apply" cannot alter the value of "this" for bound function 

    As given in the code above, "this" value for any "Bound Function" CANNOT be altered through call/apply . Also, if the "this" parameter is not explicitly passed to bind, "current object" (and hence the value of "this" ) is set to "window" in Non strict mode and "undefined" in strict mode. One more thing. Binding an already bound function does not change the value of "this" . It remains set as the value set by first bind function.

  5. While Object Creation through "new" :

    Inside a constructor function, the "current object" (and hence the value of "this" ) references the object that is currently being created through "new" irrespective of the bind status of the function. However if the constructor is a bound function it shall get called with predefined set of arguments as set for the bound function.

  6. Inside Inline DOM event handler :

    Please look at the following HTML Snippet

     <button onclick='this.style.color=white'>Hello World</button> <div style='width:100px;height:100px;' onclick='OnDivClick(event,this)'>Hello World</div> 

    The "this" in above examples refer to "button" element and the "div" element respectively.

    In the first example, the font color of the button shall be set to white when it is clicked.

    In the second example when the "div" element is clicked it shall call the OnDivClick function with its second parameter referencing the clicked div element. However the value of "this" within OnDivClick SHALL NOT reference the clicked div element. It shall be set as the "window object" or "undefined" in Non strict and Strict Modes respectively (if OnDivClick is an unbound function ) or set to a predefined Bound value (if OnDivClick is a bound function )

The following summarizes the entire article

  1. In Global Context "this" always refers to the "window" object

  2. Whenever a function is invoked, it is invoked in context of an object ( "current object" ). If the current object is not explicitly provided, the current object is the "window object" in NON Strict Mode and "undefined" in Strict Mode by default.

  3. The value of "this" within a Non Bound function is the reference to object in context of which the function is invoked ( "current object" )

  4. The value of "this" within a Non Bound function can be overriden by call and apply methods of the function.

  5. The value of "this" is fixed for a Bound function and cannot be overriden by call and apply methods of the function.

  6. Binding and already bound function does not change the value of "this". It remains set as the value set by first bind function.

  7. The value of "this" within a constructor is the object that is being created and initialized

  8. The value of "this" within an inline DOM event handler is reference to the element for which the event handler is given.

Whould this help? (Most confusion of 'this' in javascript is coming from the fact that it generally is not linked to your object, but to the current executing scope — that might not be exactly how it works but is always feels like that to me — see the article for a complete explanation)

this use for Scope just like this

  <script type="text/javascript" language="javascript"> $('#tbleName tbody tr').each(function{ var txt=''; txt += $(this).find("td").eq(0).text(); \\same as above but synatx different var txt1=''; txt1+=$('#tbleName tbody tr').eq(0).text(); alert(txt1) }); </script> 

value of txt1 and txt is same in Above example $(this)=$('#tbleName tbody tr') is Same

"this" is all about scope. Every function has its own scope, and since everything in JS is an object, even a function can store some values into itself using "this".

 $('#a').click(function(){ console.log($(this).attr('href')); }); 

The value of "this" depends on the "context" in which the function is executed. The context can be any object or the global object, ie, window.

So the Semantic of "this" is different from the traditional OOP languages. And it causes problems: 1. when a function is passed to another variable (most likely, a callback); and 2. when a closure is invoked from a member method of a class.

In both cases, this is set to window.

In pseudoclassical terms, the way many lectures teach the 'this' keyword is as an object instantiated by a class or object constructor. Each time a new object is constructed from a class, imagine that under the hood a local instance of a 'this' object is created and returned. I remember it taught like this:

 function Car(make, model, year) { var this = {}; // under the hood, so to speak this.make = make; this.model = model; this.year = year; return this; // under the hood } var mycar = new Car('Eagle', 'Talon TSi', 1993); // ========= under the hood var this = {}; this.make = 'Eagle'; this.model = 'Talon TSi'; this.year = 1993; return this;