JavaScript's "this" keyword can be a bit tricky to work with depending on the context in which it's used. When it's used with patterns such as the Prototype or Revealing Prototype patterns working with "this" can be challenging in some cases. Unlike languages such as C# or Java, "this" can change context. For example, if a Calculator object named calc calls an add() function then "this" represents the Calculator object which means you can easily access any variables defined in the object such as a variable named tax by simply using this.tax.
calc.add(2, 2); //Using "this" inside of the add() function gets you to the calc object
However, if add() makes a call to another function then "this" changes context and no longer represents the Calculator object. In fact, "this" will change to the window object which means you can no longer access variables defined in the Calculator object such as tax. That presents a bit of a problem that’s especially challenging if you’ve never dealt with it before.
There are several ways to handle this challenge. First, you can pass "this" as a parameter to other functions. An example of passing "this" between functions is shown next. If a Calculator object calls a clearNumbers() function then you can easily access the Calculator object's constructor variables within the function. However, once clearNumbers() calls other functions such as setVal() or setEquation(), "this" changes context. To account for the change, the code passes "this" as a parameter to each of the functions and they then use it like normal. Although this type of code works, it pollutes your function parameters in some cases and becomes a little messy to work with (at least in my opinion).
var Calculator = function (eq) {
//state goes here
this.eqCtl = document.getElementById(eq);
this.lastNumber;
this.equalsPressed;
this.operatorSet;
this.tax;
};
Calculator.prototype = function () {
//private members
var add = function (x, y) {
this.eqCtl.innerHTML = x + y + this.tax;
},
subtract = function (x, y) {
this.eqCtl.innerHTML = x – y + this.tax;
},
setVal = function (val, thisObj) {
thisObj.currNumberCtl.innerHTML = val;
},
setEquation = function (val, thisObj) {
thisObj.eqCtl.innerHTML = val;
},
//Other functions omitted for brevity
clearNumbers = function () {
this.lastNumber = null;
this.equalsPressed = this.operatorSet = false;
//Pass the Calculator object that called clearNumbers()
//to other functions as a parameter
setVal('0', this);
setEquation('', this);
};
//public members
return {
add: add,
subtract: subtract,
clearNumbers: clearNumbers
};
} ();
Another technique that can be used involves JavaScript's call() function. This function can be used to invoke functions and set the context of "this" while the call is being made. For example, if you want to call a function named setVal() and preserve the current value of "this" as the call is made then you can do the following:
setVal.call(this, 'yourParameterValue');
The current value of "this" will be passed along automatically to the setVal() function and it can safely use this.tax in the case of a Calculator object.
The following code uses the call() function to update the code shown earlier. The clearNumbers() function uses JavaScript's call() function to invoke the setVal() and setEquation() functions and preserve the current value of "this" in the process. Notice that the setVal() and setEquation() functions no longer need the extra parameter as the functions shown earlier did and can simply use "this" to access Calculator object variables defined in the object's constructor. This simplifies the call by eliminating the need for the extra parameter and makes the code a lot cleaner.
var Calculator = function (eq) {
//state goes here
this.eqCtl = document.getElementById(eq);
this.lastNumber;
this.equalsPressed;
this.operatorSet;
this.tax;
};
Calculator.prototype = function () {
//private members
var add = function (x, y) {
this.eqCtl.innerHTML = x + y + this.tax;
},
subtract = function (x, y) {
this.eqCtl.innerHTML = x – y + this.tax;
},
setVal = function (val) {
this.currNumberCtl.innerHTML = val;
},
setEquation = function (val) {
this.eqCtl.innerHTML = val;
},
//Other functions omitted for brevity
clearNumbers = function () {
this.lastNumber = null;
this.equalsPressed = this.operatorSet = false;
//Set context of "this" to the Calculator object that called clearNumbers()
setVal.call(this, '0');
setEquation.call(this, '');
};
//public members
return {
add: add,
subtract: subtract,
clearNumbers: clearNumbers
};
} ();
Another example of where “this” gets tricky is inside of jQuery event handlers. For example, assume that an init() function is called that adds a click event to DOM elements. What if you want to get to a value of “this” representing the container Calculator object while inside of the click event handler function? The context of “this” changes to the anchor tag making it challenging. Two potential options that can be used are shown next.
The first option is to store the value of “this” as a variable outside of the click event handler function. By doing this a closure is created and you can still access the original value of “this” when the event fires:
Calculator.prototype = {
//private members
init: function() {
//Option 1 for working with "this"
var calcObject = this;
$('a').click(function () {
//Can't simply use this or $(this)
//since "this" represents the anchor now
//calcObject will represent the Calculator object
calcObject.highlight($(this));
});
},
highlight: function(anchor) {
anchor.toggleClass('highlight');
}
};
Another option is to use an overloaded version of various jQuery event handlers such as on() to pass “this” and make it accessible through the event object:
Calculator.prototype = {
//private members
init: function() {
//Option 2 for working with "this"
//Pass "this" into the on() call
$('a').on('click', { calcObject: this }, function (event) {
//Access the original value of "this"
//through the event object's data property
event.data.calcObject.highlight($(this));
});
},
highlight: function(anchor) {
anchor.toggleClass('highlight');
}
};
Notice that “this” is assigned to an object literal property named calcObject in the on() parameters. Once the click event fires the event object passed to the callback function can be used to get to the data property which exposes the calcObject value that was passed in.
Although working with JavaScript’s “this” keyword can be challenging in some scenarios, there are several different techniques that can be used to make it easier to work with. Have any other techniques you like to use? Feel free to leave a comment and share your technique with everyone.
Videos on JavaScript and jQuery
If you're interested in additional information about structuring JavaScript code check out my Structuring JavaScript Code course created for PluralSight. Here's a sample from the course covering closures.
Demo - Working with Closures in JavaScript
A sample video from the jQuery programming course that covers using the each() function is shown next:
Demo – Using jQuery’s each() Function
