Course contentsShow
← JavaScript
Lesson 575 of 2,72314. The 'this' KeywordFree lesson

Class Methods and Arrow Properties

Using arrow functions as class fields to auto-bind 'this' and avoid losing context in callbacks.

Class Methods and Arrow Properties

What you'll learn: How to use arrow functions as class fields to lock in this and prevent context loss in class-based code.


When writing classes in JavaScript, traditional methods suffer from the same this binding issues you've already seen—if you pass a method as a callback, it loses its connection to the instance.

The Traditional Problem

class Counter {
  constructor() {
    this.count = 0;
  }
  
  increment() {
    this.count++;
  }
}

const counter = new Counter();
const callback = counter.increment;
callback(); // Error: 'this' is undefined!

The increment method loses this when extracted.

The Arrow Property Solution

By defining methods as arrow function class fields, you create a function that lexically captures this at the moment the instance is created:

class Counter {
  constructor() {
    this.count = 0;
  }
  
  increment = () => {
    this.count++;
  }
}

const counter = new Counter();
const callback = counter.increment;
callback(); // Works! this.count is now 1

How It Works

Arrow functions don't have their own this—they inherit it from the surrounding scope. When used as a class field, that "surrounding scope" is the constructor execution, where this refers to the new instance. The arrow function permanently remembers that instance.

When to Use This Pattern

  • Event handlers in UI frameworks (React, DOM events)
  • Callback functions passed to timers or third-party libraries
  • Any time a method will be used detached from its object

The Trade-off

Each instance gets its own copy of the function (stored on the instance, not the prototype), which uses slightly more memory. But for callbacks, this is usually worth the convenience of never losing this.

Key Takeaway: Arrow function class fields auto-bind this to the instance, making them perfect for callbacks where traditional methods would lose context.