It can also be nice when you're writing instance methods on a prototype. for instance:
var Person = function(name) {
var self = this;
self.name = name
};
Person.prototype = new function() {
var prototype = this;
prototype.sayHello = function() {
var self = this;
return "Hello\n\n-- " + self.name;
};
};
var me = new Person('Peter');
console.log(me.sayHello());
Obviously that's a pretty contrived example but it illustrates the idea. It makes it really clear exactly what "this" means at different points in your code. As a bonus, if I had to reference the current context inside of a prototype method, "this" is now available.
I don't like `var self` at all and I find there are vanishingly few places where you can't just bind a function appropriately, but one important thing to note, if you do go down this route, is that `self` is an alias for the `window` object, so if you happen to miss out that `var self` assignment at some point, you may get unexpected results.
On that basis, if you must do this, I would suggest `var _this`, `var scope` (though that would probably be confusing if you had the misfortune to be using Angular), `var me` (unless you happen to find anthropomorphism distasteful) or... well, anything other than `var self`, really.
Interesting, I never knew that `self === window` – thanks for bringing that up. I'm not particularly attached to the name, just wanted to show an example where assigning `this` to some local variable is useful.
Do you have a source? I don't understand how a closure over a single variable (this), instead of reassigning the value of the variable in a specific scope, would result in a 50% improvement in performance. Also -- the phrase "50% improvement in performance" itself is kind of dubious, no?