TypeScript中：用Object.assign替代构造函数重载是否可行？

Great question! This pattern might feel quick and convenient at first glance, but it comes with several critical drawbacks that make proper constructor overloads or dedicated initialization logic a far better choice. Let’s break down the key reasons to steer clear of it:

• You bypass critical class initialization logic
  Classes often have essential setup code in their constructors—think validation checks, default value assignments, or initializing private internal state. When you use Object.assign after creating an empty instance, none of this logic runs, leaving your object in an inconsistent state. For example:

  class MyClass {
    public a: string;
    public b: string;
    #internalId: string;
  
    constructor() {
      // This setup code gets completely skipped!
      this.#internalId = crypto.randomUUID();
      if (!this.a) throw new Error("Property 'a' is required");
    }
  }
  
  // The instance here has no valid #internalId, and no validation runs
  const obj = Object.assign(new MyClass(), {a: 'check', b: 'mate'});
  

• Type safety gaps and unexpected behavior
  TypeScript’s type system can’t fully enforce constraints with this pattern. For example, if your class has readonly properties or properties with strict type guards, Object.assign will happily overwrite them or assign invalid values, breaking runtime expectations without triggering type errors:

  class User {
    readonly id: number;
    public name: string;
  
    constructor(userId: number) {
      this.id = userId;
    }
  }
  
  // Type won't flag this, but you're mutating a readonly property!
  const badUser = Object.assign(new User(123), {id: 456, name: "Alice"});
  

• Private/protected properties can’t be initialized this way
  Object.assign only works with public class members. If your class relies on private or protected properties for internal state, you can’t set them via this pattern—they’ll stay stuck in their default (often undefined) state, breaking core class functionality:

  class Order {
    public total: number;
    protected status: 'pending' | 'shipped';
  
    constructor() {
      this.status = 'pending';
    }
  }
  
  // `status` remains 'pending'—you can't overwrite it via Object.assign
  const order = Object.assign(new Order(), {total: 99.99, status: 'shipped'});
  

• It breaks encapsulation and maintainability
  OOP principles emphasize that a class should control its own initialization. When you bypass the constructor to assign properties directly, you create tight coupling between external code and the class’s internal structure. If the class’s properties or initialization logic change later (e.g., renaming a property, adding new required fields), all the Object.assign calls will break silently.

Instead, using constructor overloads gives you full control over initialization, maintains type safety, and keeps your class logic encapsulated:

class MyClass {
  public a: string;
  public b: string;
  #internalId: string;

  // Empty constructor overload
  constructor();
  // Constructor with properties overload
  constructor(props: {a: string, b: string});
  // Core implementation
  constructor(props?: {a: string, b: string}) {
    this.#internalId = crypto.randomUUID();
    if (props) {
      this.a = props.a;
      this.b = props.b;
    }
    // Run validation or other setup consistently
    if (!this.a) throw new Error("Property 'a' is required");
  }
}

// Safe, consistent initialization
const obj1 = new MyClass(); // Handles empty case properly
const obj2 = new MyClass({a: 'check', b: 'mate'}); // Follows all class rules

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