In the case you are asking about, this represents the HTML DOM element.

So it would be the <a> element that was clicked on.

The code that you have would work, but is executed from the global context, which means that this refers to the global object.

<script type="text/javascript">
var foo = function(param) {
    param.innerHTML = "Not a button";
};
</script>
<button onclick="foo(this)" id="bar">Button</button>

You can also use the non-inline alternative, which attached to and executed from the specific element context which allows you to access the element from this.

<script type="text/javascript">
document.getElementById('bar').onclick = function() {
    this.innerHTML = "Not a button";
};
</script>
<button id="bar">Button</button>

That's because you aren't passing a reference to this in the JavaScript function call. this in the JavaScript function doesn't refer to the same object as in the onClick example. Try this instead:

 <li onClick="foo(this)"></li>

 function foo(item){ alert(item.tagName); }

The reason is this refers to the global Window object inside the function.

You have to pass this to the function so that you can refer that inside the function:

.active{
  color:green;
  font-size: 20px;
}

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<div class="class1" onClick="TestFunction(this);">Click</div>

<script>
function TestFunction(el) {
  console.log(this.constructor.name) //Window
  $(el).addClass('active');
}
</script>

Though it is better to avoid inline event handler:

$('.class1').click(function(){
  $(this).addClass('active');
});

.active{
  color:green;
  font-size: 20px;
}

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<div class="class1">Click</div>

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 recommended.

   • 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 recommended when writing maintainable code.

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

   • 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/compiler 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 outcome.

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 comes 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>