如何创建可生成类新实例的方法？——实现Bmw类的createNewBmwCar静态方法

Hey there! Let's break down how to fix your Bmw class's static method and cover general ways to create class instances in JavaScript.

Fixing the createNewBmwCar Method #

First, a quick critical note: since Bmw extends Car, your constructor must call super() before accessing this—otherwise you'll hit a runtime error. Then, for the static method, we just need to accept the options parameter (matching your constructor's requirement) and return a new Bmw instance with those options.

Here's the corrected code:

class Bmw extends Car {
  constructor(options) {
    // Call parent class constructor first (required for inherited classes)
    super();
    this._model = options.model;
    this._year = options.year;
    this._price = options.price;
  }

  static createNewBmwCar(options) {
    // Pass the input options to the Bmw constructor and return the new instance
    return new Bmw(options);
  }
}

General Ways to Create Class Instances #

Let's cover the most common approaches for generating class instances, beyond just your specific Bmw case:

1. Static Factory Method (Your Use Case)

This is ideal for encapsulating instance creation logic—like setting default values, validating inputs, or creating different variants of the class. To make it even more reusable (for subclasses of Bmw), use new this instead of hardcoding new Bmw:

static createNewBmwCar(options = {}) {
  // Set default values if no options are provided
  const defaults = { model: '3 Series', year: new Date().getFullYear(), price: 40000 };
  const finalOptions = { ...defaults, ...options };

  // Add simple input validation
  if (finalOptions.year < 2000) {
    throw new Error("We don't support BMW models older than 2000");
  }

  // `this` refers to the current class (works seamlessly for subclasses!)
  return new this(finalOptions);
}

2. Direct Constructor Call

The simplest, most straightforward way—just use the new keyword directly with the class and its required arguments:

const myX5 = new Bmw({ model: 'X5', year: 2024, price: 65000 });

Perfect for scenarios where you don't need extra logic around instance creation.

3. Dynamic Instance Creation (For Unknown Classes)

If you have a reference to a class stored in a variable (e.g., a dynamic selection between car brands), you can still create instances with new:

const targetCarClass = Bmw; // Could be any subclass of Car
const myDynamicBmw = new targetCarClass({ model: 'M4', year: 2024, price: 78000 });

You can also use Reflect.construct() as an alternative to new—it works identically but is useful in more dynamic or meta-programming scenarios:

const myReflectBmw = Reflect.construct(Bmw, [{ model: 'X3', year: 2023, price: 52000 }]);

4. Object.create() (Advanced, Rarely Used)

This method creates an instance without calling the class constructor. You'll have to manually initialize all properties, so it's only useful for edge cases where you don't want to run the constructor logic:

const rawBmw = Object.create(Bmw.prototype);
rawBmw._model = '5 Series';
rawBmw._year = 2023;
rawBmw._price = 55000;

Note: This skips super() and any constructor logic, so it's not recommended for most standard use cases.

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