为何带显式this参数的函数可赋值给宽松签名？相关严格选项问询

Great question! Let's unpack these two closely related TypeScript questions one by one.

In TypeScript, the this parameter is a special pseudo-parameter—it doesn't exist in the compiled JavaScript output, and it's only used by the type checker to enforce what the value of this should be when the function is called.

When evaluating function compatibility (whether one function can be safely assigned to another), TypeScript ignores the this parameter entirely. Compatibility is determined by two core factors:

• The number and types of the actual, non-this parameters
• The function's return type

So a function with an explicit this parameter is treated as having the same "callable shape" as a function without that this parameter (as long as their other parameters and return types match). That's why you can assign it to a more generic signature that doesn't specify a this constraint.

First, yes—this assignment absolutely can trigger runtime errors. Here's a concrete example to illustrate:

function a(this: { x: number }): string {
  return `x is ${this.x}`;
}

// Assign to a signature that doesn't enforce any `this` context
const b: () => string = a;

// Calling b() will throw a runtime error: `this` is undefined (in strict mode) or the global object
b();

Now, regarding --strict options:

• --strictFunctionTypes does strengthen type checking for function parameters (enforcing contravariance for parameter types), but it doesn't alter how this parameters are handled in compatibility checks. This is intentional—TypeScript treats this as a contextual constraint rather than part of the function's parameter list that's validated during assignment.
• There isn't a specific --strict sub-option that overrides this behavior. The current design prioritizes flexibility in passing functions around, even if it introduces a potential runtime risk if you're not careful about how the function is invoked.

To avoid these errors, you can:

• Always ensure the function is called with the correct this context (using Function.call(), Function.apply(), or binding it with bind())
• Use type assertions only if you're 100% certain the this context will be valid at runtime (note: this bypasses type checking, so use sparingly)
• Wrap the function in a closure that explicitly sets the correct this value before assigning it to a generic signature

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