I am confused:

• why with inline onlick, we have to write onclick="hello()", but in JS, we should write btn.onclick=hello or btn.addEventListener('click',hello);

• for regular function, why with inline onlick, "this" refers to window, but with js call, "this" refers to button.

• I don't understand last two buttons

according to w3school, In a function, this refers to the global object. .asp

In regular functions the this keyword represented the object that called the function, which could be the window, the document, a button or whatever. .asp

const arrayBtn = document.querySelector(".arrowFunc");
const regBtn = document.querySelector(".regFunc");
hello = () => console.log("i am arrow function" + this);
function hiii(){
  console.log("i am regular function" + this);
}
arrayBtn.addEventListener("click", hello);
regBtn.addEventListener("click", hiii);

<button onclick="hello()">This calls an arrow function with an inline onclick</button>
<button class="arrowFunc">This calls an arrow function with event listener</button>
<button onclick="hiii()">This calls an regular function with an inline onclick</button>
<button class="regFunc">This calls an regular function with event listener</button>
<button onclick="function tes(){console.log(this)}tes()">button</button>
<button onclick="console.log(this)">button</button>

I am confused:

• why with inline onlick, we have to write onclick="hello()", but in JS, we should write btn.onclick=hello or btn.addEventListener('click',hello);

• for regular function, why with inline onlick, "this" refers to window, but with js call, "this" refers to button.

• I don't understand last two buttons

according to w3school, In a function, this refers to the global object. https://www.w3schools./js/js_this.asp

In regular functions the this keyword represented the object that called the function, which could be the window, the document, a button or whatever. https://www.w3schools./js/js_arrow_function.asp

const arrayBtn = document.querySelector(".arrowFunc");
const regBtn = document.querySelector(".regFunc");
hello = () => console.log("i am arrow function" + this);
function hiii(){
  console.log("i am regular function" + this);
}
arrayBtn.addEventListener("click", hello);
regBtn.addEventListener("click", hiii);

<button onclick="hello()">This calls an arrow function with an inline onclick</button>
<button class="arrowFunc">This calls an arrow function with event listener</button>
<button onclick="hiii()">This calls an regular function with an inline onclick</button>
<button class="regFunc">This calls an regular function with event listener</button>
<button onclick="function tes(){console.log(this)}tes()">button</button>
<button onclick="console.log(this)">button</button>

[Log] i am arrow function[object Window] <br>
[Log] i am arrow function[object Window] <br>
[Log] i am regular function[object Window] <br>
[Log] i am regular function[object HTMLButtonElement] <br>
[Log] Window {document: #document, window: Window, NaN: NaN, nalert: function, obj: {name: "my_obj"}, …} <br>
[Log] <button onclick="console.log(this)">button</button>

• javascript
• html
• onclick
• this
• onclicklistener

• I'm also confused about this even after being a developer for years ! – Ari Seyhun Commented Sep 13, 2019 at 2:34
• Also, try to link MDN rather than W3Schools as a source. It is more official. – Ari Seyhun Commented Sep 13, 2019 at 2:38
• What's to understand? You wrote how this context is interpreted already. this, in a regular function, within the method (function) of an Object, refers to the Object, which in the case of an Event is the Element. So the function assigned to the onclick of a Element is the method, and the button is the Object. this within an Arrow function scopes up to wherever your last scope is, global if not within a class or constructor. Note that a constructor is a function. It only bees an Object upon calling new on it. – StackSlave Commented Sep 13, 2019 at 2:53

2 Answers 2

about this values.

1. Arrow functions capture and always use their lexical this value, meaning the one that was in effect when their arrow function expression was evaluated. Evaluation usually occurs when executing an assignment operation or when calculating parameter values for a function call which has arrow functions in its argument list.

   • Arrow functions cannot be used as constructors.

2. Non arrow functions called as constructors using new (or super when extending a class) see the object under construction as their this value.

3. Bound functions save and use a this value supplied as the first argument to the bind method of another function.

   • Bound functions ignore their saved this value if called as constructors - but this is rare enough to be considered an edge case and is not generally remended.

   • Binding an arrow function has no effect on its this value but could be used to predefine a set of parameter values.

4. Functions called using either their call or apply object methods take their this value from the (first) thisValue argument supplied to call or apply, subject to JavaScript mode:

   • In strict mode null or undefined values provided for thisValue are used as the function's this value. In sloppy mode however, null or undefined are replaced by window before making the call.

   • Arrow and bound functions can be called using these methods (e.g. to supply arguments) but use their own recorded this value.

5. Provided none of the preceding rules apply, functions explicitly called as a method of an object use the object as their this value.

   E.G. in a call of form

   someObject.methodName( optionalArgumentList)
   

   this in methodName refers to someObject if the method is a regular function.

6. In strict mode, the default value of this in an unqualified function call is undefined. In sloppy mode (dating from when JavaScript was first introduced) this is window. For demonstration:

function a () {
    "use strict";
    console.log("in strict mode functions the default this is ", this);
};
let b = function() {
    console.log("but in non strict mode,  the default this is ",
        this === window ? "window" : this
    );
}

a(); // undefined
b(); // window

7. Code provided as a text string in calls to the global Function constructor, SetTimeout, related timer calls, and event attributes in HTML source, is treated as a "script" in its own right and creates a function that

   • operates in sloppy mode if strict mode is not invoked by the supplied source code,

   • operates in strict mode if strict mode is invoked in the source.

   While this alters the default this value of the function, is is also an edge case because none of these methods of creating a function is remended when writing maintainable code.

8. The this value when evaluating code with eval is outside the scope of this question, but for pleteness:

   • Direct calls to eval inherit this from the calling context unless the evaluated code invokes strict mode - in which case this is undefined during code evaluation.

   • Indirect calls to eval use window (i.e. the global object) as this even if they invoke strict mode (Ref.)

   This is also an edge case since because of its dangers, eval should never be used because you can.

Inline event handlers in HTML

Event handler content attributes in an HTML tag of the form

    onEventName="text"

are converted into event handler functions by the HTML parser using steps equivalent to

1. Save the text as the attribute's string value.

2. Use the JavaScript parser/piler to create an event handler function from the text by including it in a template of form

   function( event) {
         // include attribute text here as body code
   }
   

3. Save the function as a property of the element under the same name as the attribute. E.G. at this point an element with an onclick text attribute will also have an onclick property which is a function.

4. Add the function to the element's internal event handler map. In practical terms this means actual event handling uses a map of listeners rather than looking for handler functions on the element.

Warning

• HTML onEventName attributes predate both standardization of the DOM and the introduction of addEventListener:

  Handlers created by the HTML parser have a legacy scope chain that minimally searches the element the event attribute belongs to, a surrounding form element if any, and the document object before reaching the global object when looking up names - which can result in obscure bugs.

Why with inline onlick, we have to write onclick="hello()", but in JS, we should write btn.onclick=hello or btn.addEventListener('click',hello);

The HTML event handler attribute is used as the body code of a event handler function created by the HTML parser. To call hello, attribute text must provide the source code to make the call, as in e.g. hello().

In JS, setting an onclick to a function object, or calling addEventListener with a function as the second parameter, adds the function to a map of handlers associated with the element. If parentheses are placed after the function name, using onclick as an example:

  onclick = myFunction();

the function is called and an attempt is made to use its return value as a handler function - and if the return value is not a function little happens. Most often this is a mistake and not the desired oute.

For regular function, why with inline onclick, "this" refers to window, but with js call, "this" refers to button.

Inside the event handler function created from an inline onclick attribute, this does refer to the button. If you call out to another function with code like hello(), you are making an unqualified call to it, so the called function uses its default this value - i.e. window if the called function operates in sloppy mode.

Following on from "Inline event handlers in HTML", you could pass on this (referring to the button) and the event object as a parameter values if you wanted to:

onclick="hello(this, event)"

Handler functions provided in JavaScript go directly into the element's map of event handlers and are called by the event system with the button as their this value (probably using call or apply, since handlers added with addEventListener aren't maintained as element property values).

<button onclick="function tes(){console.log(this)}tes()">button>/button>

Creates the event handler function

function onclick(event) {
    function tes(){
        console.log(this)
    }
    tes()
}

Strict mode was not invoked in the button tag's event attribute text, so both onclick and tes are in sloppy mode. tes is called without qualification, so it uses and logs its default this value which is window.

In regards to "about this values", none of rules 1 - 5 apply, so rule 6 es into effect.

<button onclick="console.log(this)">button</button>

creates a handler function

function onclick(event) {
    console.log(this)
}

which is called with the button element as its this value by the event system as it would for any other handler. console.log is showing the outer HTML for the button in the log. If you change this to a string, the log will tell you its an HTMLButtonElement element instead:

<button onclick="console.log(this.toString())">button</button>

The text hello() in the inline <button onclick="hello()"> is actually a small JavaScript program itself — you should never use this; it’s an obsolete old-fashioned way to make anything work and should be forgotten.

Instead, the correct way in JavaScript is like this:

function hello(){}

button.addEventListener("click", hello);

where hello is the name of a function (not a JavaScript program).

As for why this is the current button? All functions can be called with a different this.

You can call the hello function with a different this if you want to.

hello.call({ turkey: true });

That’s how you call hello and provide { turkey: true } as the this object.

It’s standard for HTML elements to call event handlers with the element as the this object.