如何阻止TypeScript中类的接口风格断言初始化并触发编译告警？

Great question! You hit the nail on the head—TypeScript does treat your class like an interface here, thanks to its structural type system. When you use as MyClass to assert a plain object, TypeScript only checks that it has the matching public properties, completely missing that the object doesn't have the class's prototype methods (like getOneAndTwo) which is why you get that runtime error.

To fix this and get compile-time warnings/errors for this kind of mismatch, here are the most effective approaches:

1. Add a private/protected "brand" property to your class #

This is the simplest way to create a nominal type (instead of structural) for your class, so TypeScript can distinguish between a real class instance and a plain object with matching properties.

Modify your MyClass definition to include a private (or protected) property—even one that doesn't hold any meaningful value:

export class MyClass {
  private _classBrand: void; // Private marker to distinguish class instances
  one: string;
  two: string;

  constructor(init?: Partial<MyClass>) {
    if (init) {
      Object.assign(this, init);
    } else {
      this.one = 'first';
      this.two = 'second';
    }
  }

  getOneAndTwo(): string {
    return `${this.one} and ${this.two}!`;
  }
}

Now, when you try to assert a plain object as MyClass:

mine = { one: 'Three', two: 'Four' } as MyClass;

TypeScript will throw a compile-time error:

Conversion of type '{ one: string; two: string; }' to type 'MyClass' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first.

This works because plain objects can't have private/protected properties, so their structure no longer matches the class's type.

2. Use runtime checks with type guards (for extra safety) #

If you want to add an extra layer of runtime protection even if someone tries to bypass the compile-time checks, you can create a type guard that uses instanceof:

function isMyClassInstance(obj: unknown): obj is MyClass {
  return obj instanceof MyClass;
}

// Usage example:
const candidate = { one: 'Three', two: 'Four' };
if (isMyClassInstance(candidate)) {
  mine = candidate;
} else {
  // TypeScript will flag this assignment as invalid
  mine = candidate; // Error: Type '{ one: string; two: string; }' is not assignable to type 'MyClass'
}

This ensures that only real instances created with new MyClass() are assigned to variables of type MyClass.

Why this happens in the first place #

As you suspected, TypeScript's structural typing means it compares types based on their members rather than their declaration origin. Since your plain object has the same public properties as MyClass, TypeScript considers them compatible when you use a type assertion. Adding private/protected members breaks this structural compatibility, forcing TypeScript to recognize that only actual class instances are valid.

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