咨询TypeScript中使用this关键字的影响及代码改写相关问题

Hey there! Let’s dig into your question about this and performance—since your team got feedback that using this hurts performance, and you switched to the let self = this pattern as a workaround.

First off, let’s bust a common myth: using this directly does NOT inherently cause performance issues in modern JavaScript/TypeScript engines (like V8, which powers Chrome and Node.js). Modern JS engines are heavily optimized, and property access via this is just as fast as accessing a variable like self in almost all real-world scenarios.

Where the "this is slow" idea comes from #

The belief that this impacts performance likely stems from very old JS engine implementations (think pre-2010) or confusion with dynamic this binding issues. Those binding problems are about correctness (making sure this refers to the right object), not speed.

The actual impacts of using this #

The real challenges with this have nothing to do with performance—they’re about code reliability and readability:

• Dynamic binding confusion: The value of this is determined by how a function is called, not where it’s defined. For example, if you pass myMethod1 as a callback to another function, this inside myMethod1 might no longer refer to your MyClass instance. This leads to bugs, not slowdowns.
• Readability in nested code: In complex code with nested functions or callbacks, tracking this bindings can get messy. Using let self = this (or const that = this) is a common way to "capture" the correct instance, but this is a fix for binding bugs, not performance.

Comparing your two code examples #

Let’s look at your original code:

export class MyClass {
  public myMethod1(data: any) {
    this.myMethod2();
  }
  public myMethod2() { }
}

And your modified version:

export class MyClass {
  public myMethod1(data: any) {
    let self = this;
    self.myMethod2();
  }
  public myMethod2() { }
}

In this specific scenario, there’s zero performance difference. The JS engine will optimize both to nearly identical machine code—self is just a reference to the same instance as this, so property lookup works the same way.

Edge cases where this might have tiny performance differences #

If you’re in an extremely hot loop doing millions of this accesses, and the engine can’t optimize the this binding (e.g., if this changes frequently or is of an unknown type), there might be a negligible speed difference. But this is an edge case, not something to worry about in typical application code.

Final takeaways #

• Don’t avoid this for performance reasons—it’s a red herring.
• Use let self = this (or better yet, arrow functions, which preserve this lexically) when you need to ensure the correct this binding in nested functions or callbacks. That’s the real purpose of this pattern.
• If your team’s feedback was focused on performance, ask for specific benchmarks or examples—modern engines don’t penalize this access.

内容的提问来源于stack exchange，提问作者Ashish Sapkale