«onclick» and «this» in javascript
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.com/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); [Log] i am arrow function[object Window]
[Log] i am arrow function[object Window]
[Log] i am regular function[object Window]
[Log] i am regular function[object HTMLButtonElement]
[Log] Window , …>
[Log] 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 becomes an Object upon calling new on it.
2 Answers 2
about this values.
- 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.
- Non arrow functions called as constructors using new (or super when extending a class) see the object under construction as their this value.
- 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.
- 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.
- 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) 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- 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.
- 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
are converted into event handler functions by the HTML parser using steps equivalent to
- Save the text as the attribute’s string value.
- Use the JavaScript parser/compiler to create an event handler function from the text by including it in a template of form
- 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:
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. question 2
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:
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).
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.
creates a handler function
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:
Change input value onclick button — pure javascript or jQuery
I have two buttons and if I click on some button I need to change value in input text and change total price (product price * value of button — 2 or 4 Qty). I know that it’s simple but I’m not good in javascript or jQuery. Answer in jsfiddle would be best.
My jsfiddle is here http://jsfiddle.net/J7m7m/1/ My simple code:
Product price: $500
Total price: $500
Total
6 Answers 6
Another simple solution for this case using jQuery. Keep in mind it’s not a good practice to use inline javascript.
I’ve added IDs to html on the total price and on the buttons. Here is the jQuery.
$('#two').click(function()< $('#count').val('2'); $('#total').text('Product price: $1000'); >); $('#four').click(function()< $('#count').val('4'); $('#total').text('Product price: $2000'); >); Try This(Simple javascript):-
function change(value) Product price: $500
Total price: $500
Total I would suggest not to do it like this, because developers need to learn to separate their JavaScript from their html. Obtrusive JavaScript isn’t good.
using html5 data attribute.
Product price: $500
Total price: $500
Total
And here is the non jQuery answer.
Product price: $500
Total price: $500
Total EDIT: It is very clear that this is a non-desired way as pointed out below (I had it coming). So in essence, this is how you would do it in plain old javascript. Most people would suggest you to use jQuery (other answer has the jQuery version) for good reason.
The value of this in onclick for a button
Why is it that when I say onclick=foo() on my button and console.log(this) in the foo function, the this variable is pointing to the window ? Since technically onclick=foo() is defined on the button so when the onclick function is called it should automatically set the value of this to the button correct? I know how to fix this but I never understood why this is happening.
it should automatically set the value of this to the button correct? and I know how to fix this IMHO its design flaw but still make question off-topic
Since if I do onclick=foo(this) somehow the correct context of this is passed which is the button. But in this case, this is pointing to the button and this wasn’t pointing to the button in the question above.
In the element you have an attribute only, there has to be a wrapper function in the deeper implementation . Notice, that this refers to the element within the onclick attribute.
2 Answers 2
In languages like Ruby or Java, this (or in case of Ruby self ) will always point to the object in which your method is defined. So in Ruby if you are working on the foo method inside the Bar class, self will always point to the object which is the instance of the Bar class.
JavaScript works quite surprisingly here. Because in JavaScript function context is defined while calling the function, not while defining it! This is what can surprise many when coming to JS from different fields. Such late binding is a powerful mechanism which allows us to re-use loosely coupled functions in variety of contexts.
To answer your question, this , when called from an onclick event handler is executed by the global context.
in my opinion it is because you did not pass your button to your function like this :
while your code is like this:
and the entry of your function is empty:
so you should pass this to your function like this:
and because the value of this is not set by the call, this will default to the global object , which is window in a browser.
for more info please check this out.