无需手动编写字段代码，实现JSON与JavaScript类对象自动互转可行吗？

Absolutely! You can absolutely automate this two-way conversion between JSON objects and class instances without writing repetitive boilerplate code for every field in your classes. Let’s break down how to handle both serialization and deserialization in JavaScript:

Serialization (Class Instance → JSON) #

Turning a class instance into plain JSON is straightforward—you can either use a generic serialization function or define a toJSON method on your classes to let JSON.stringify handle it automatically.

Generic Serialization Function #

This works for any class instance by recursively copying enumerable properties:

function serialize(instance) {
  const result = {};
  for (const [key, value] of Object.entries(instance)) {
    // Recursively serialize nested objects (skip built-in types like Date/RegExp)
    if (value instanceof Object && !(value instanceof Date || value instanceof RegExp)) {
      result[key] = serialize(value);
    } else {
      result[key] = value;
    }
  }
  return result;
}

// Usage example:
const driver = new Driver("Boo", new Car("Foo"));
const json = JSON.stringify(serialize(driver));
// Output: {"name":"Boo","car":{"model":"Foo"}}

Class-Specific toJSON Method #

For more control, add a toJSON method to your classes (this gets called automatically by JSON.stringify):

class Car {
  constructor(model) {
    this.model = model;
  }

  toJSON() {
    // Return a plain object with only the properties you want to serialize
    return { ...this };
  }
}

class Driver {
  constructor(name, car) {
    this.name = name;
    this.car = car;
  }

  toJSON() {
    return { ...this };
  }
}

// Usage example:
const driver = new Driver("Boo", new Car("Foo"));
const json = JSON.stringify(driver);
// Output: {"name":"Boo","car":{"model":"Foo"}}

Deserialization (JSON → Class Instance) #

Converting plain JSON back to class instances requires telling your code which fields map to which classes. You can create a generic deserializer with a mapping configuration, or use decorators for cleaner type hints.

Generic Deserializer with Mapping #

Define a mapping that links classes to their nested property types, then recursively build instances:

// First, define your classes
class Car {
  constructor(model) {
    this.model = model;
  }
}

class Driver {
  constructor(name, car) {
    this.name = name;
    this.car = car;
  }
}

// Create a mapping to track which properties belong to which classes
const classTypeMap = {
  Driver: {
    ctor: Driver,
    nestedProps: { car: Car }
  },
  Car: { ctor: Car }
};

function deserialize(json, targetClass) {
  const classConfig = classTypeMap[targetClass.name];
  if (!classConfig) throw new Error(`No type mapping found for ${targetClass.name}`);

  const instance = new classConfig.ctor();
  for (const [key, value] of Object.entries(json)) {
    const nestedClass = classConfig.nestedProps?.[key];
    // If the property maps to a class, recursively deserialize it
    if (nestedClass && typeof value === 'object' && value !== null) {
      instance[key] = deserialize(value, nestedClass);
    } else {
      instance[key] = value;
    }
  }
  return instance;
}

// Usage example:
const json = { name: "Boo", car: { model: "Foo" } };
const driverInstance = deserialize(json, Driver);

console.log(driverInstance instanceof Driver); // true
console.log(driverInstance.car instanceof Car); // true

Advanced: Using Decorators for Cleaner Type Hints #

If you’re using modern JavaScript (with decorator support enabled), you can mark class properties with their target types to avoid manual mapping:

// Decorator to mark property types
function Type(targetClass) {
  return function(target, propertyKey) {
    if (!target.constructor.propertyTypes) {
      target.constructor.propertyTypes = {};
    }
    target.constructor.propertyTypes[propertyKey] = targetClass;
  };
}

// Define classes with type decorators
class Car {
  constructor(model) {
    this.model = model;
  }
}

class Driver {
  constructor(name, car) {
    this.name = name;
    this.car = car;
  }

  @Type(Car)
  car;
}

// Updated deserializer that reads decorator metadata
function deserialize(json, targetClass) {
  const instance = new targetClass();
  const propertyTypes = targetClass.propertyTypes || {};

  for (const [key, value] of Object.entries(json)) {
    const nestedClass = propertyTypes[key];
    if (nestedClass && typeof value === 'object' && value !== null) {
      instance[key] = deserialize(value, nestedClass);
    } else {
      instance[key] = value;
    }
  }
  return instance;
}

// Usage is the same as before!
const json = { name: "Boo", car: { model: "Foo" } };
const driverInstance = deserialize(json, Driver);

Notes & Edge Cases #

• Circular References: If your instances have circular references (e.g., a Driver that references another Driver), you’ll need to add logic to track visited objects to avoid infinite loops during serialization/deserialization.
• Private Fields: Private class fields (marked with #) aren’t accessible via Object.entries, so you’ll need to add getters or explicitly include them in your serialization logic.
• Inheritance: If your classes extend other classes, update your deserializer to handle parent class properties (e.g., recursively check parent classes for type mappings).

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