The this keyword

This chapter follows Scope and closures.

In JavaScript, this is a binding that depends on how a function is invoked, not where it is declared. That is unlike lexical variables and unlike Python’s explicit self parameter.

Default binding

A plain function call in non-strict sloppy mode sets this to the global object (window in browsers, globalThis everywhere). In strict mode, a plain call leaves this as undefined.

1
'use strict';
2
function show() {
3
  console.log(this);
4
}
5
show(); // undefined

Implicit binding (method call)

When a function is called as obj.method(), this is obj for the duration of that call—as long as the call stays in method form.

1
const user = {
2
  name: 'Ada',
3
  greet() {
4
    return this.name;
5
  },
6
};
7
user.greet(); // 'Ada'

Extracting the method loses the receiver:

1
const g = user.greet;
2
g(); // not 'Ada' — default binding

Explicit binding

call, apply, and bind set this explicitly. bind returns a new function with a fixed receiver.

1
function tag() {
2
  return this.id;
3
}
4
const ctx = { id: 42 };
5
tag.call(ctx); // 42
6

7
const bound = tag.bind(ctx);
8
bound(); // 42

Libraries often bind handlers so callbacks keep the right this.

new binding

With new Constructor(), a fresh object is created, linked to the prototype, and this inside the constructor refers to that object until the constructor returns (if it returns an object, that object is used instead).

1
function Point(x, y) {
2
  this.x = x;
3
  this.y = y;
4
}
5
const p = new Point(1, 2);

Arrow functions and lexical this

Arrow functions do not have their own this. They inherit this from the enclosing lexical scope at creation time—like a closure over the current receiver.

1
const timer = {
2
  seconds: 0,
3
  start() {
4
    setInterval(() => {
5
      this.seconds++; // lexically outer this = timer
6
    }, 1000);
7
  },
8
};

Use arrows for callbacks when you want outer this; use regular functions for methods that must receive dynamic this.

Classes and this

Class methods use the same implicit binding as object methods. In constructors and class fields, this refers to the instance under construction. Unbound methods passed as callbacks still suffer the extraction problem—arrow field initializers or bind in the constructor are common fixes.

Next: Higher-order functions and callbacks.