14 Instanzen von Klassen kopieren: .clone() vs. Kopierkonstruktoren

In diesem Kapitel betrachten wir zwei Techniken zur Implementierung des Kopierens von Klasseninstanzen

• .clone()-Methoden
• Sogenannte Kopierkonstruktoren, Konstruktoren, die eine weitere Instanz der aktuellen Klasse erhalten und diese zur Initialisierung der aktuellen Instanz verwenden.

14.1 .clone()-Methoden

Diese Technik führt eine Methode .clone() pro Klasse ein, deren Instanzen kopiert werden sollen. Sie gibt eine tiefe Kopie von this zurück. Das folgende Beispiel zeigt drei Klassen, die geklont werden können.

class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }
  clone() {
    return new Point(this.x, this.y);
  }
}
class Color {
  constructor(name) {
    this.name = name;
  }
  clone() {
    return new Color(this.name);
  }
}
class ColorPoint extends Point {
  constructor(x, y, color) {
    super(x, y);
    this.color = color;
  }
  clone() {
    return new ColorPoint(
      this.x, this.y, this.color.clone()); // (A)
  }
}

Zeile A demonstriert einen wichtigen Aspekt dieser Technik: zusammengesetzte Instanzeigenschaftswerte müssen ebenfalls rekursiv geklont werden.

14.2 Statische Factory-Methoden

Ein Kopierkonstruktor ist ein Konstruktor, der eine weitere Instanz der aktuellen Klasse verwendet, um die aktuelle Instanz einzurichten. Kopierkonstruktoren sind in statischen Sprachen wie C++ und Java beliebt, wo Sie über statische Überladung mehrere Versionen eines Konstruktors bereitstellen können. Hier bedeutet statisch, dass die Wahl, welche Version verwendet werden soll, zur Kompilierzeit getroffen wird.

In JavaScript müssen wir diese Entscheidung zur Laufzeit treffen, und das führt zu uneleganten Code

class Point {
  constructor(...args) {
    if (args[0] instanceof Point) {
      // Copy constructor
      const [other] = args;
      this.x = other.x;
      this.y = other.y;
    } else {
      const [x, y] = args;
      this.x = x;
      this.y = y;
    }
  }
}

So würden Sie diese Klasse verwenden

const original = new Point(-1, 4);
const copy = new Point(original);
assert.deepEqual(copy, original);

Statische Factory-Methoden sind eine Alternative zu Konstruktoren und funktionieren in diesem Fall besser, da wir die gewünschte Funktionalität direkt aufrufen können. (Hier bedeutet statisch, dass diese Factory-Methoden Klassenmethoden sind.)

Im folgenden Beispiel haben die drei Klassen Point, Color und ColorPoint jeweils eine statische Factory-Methode .from()

class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }
  static from(other) {
    return new Point(other.x, other.y);
  }
}
class Color {
  constructor(name) {
    this.name = name;
  }
  static from(other) {
    return new Color(other.name);
  }
}
class ColorPoint extends Point {
  constructor(x, y, color) {
    super(x, y);
    this.color = color;
  }
  static from(other) {
    return new ColorPoint(
      other.x, other.y, Color.from(other.color)); // (A)
  }
}

In Zeile A kopieren wir wieder rekursiv.

So funktioniert ColorPoint.from()

const original = new ColorPoint(-1, 4, new Color('red'));
const copy = ColorPoint.from(original);
assert.deepEqual(copy, original);

14.3 Danksagungen

• Ron Korvig hat mich daran erinnert, statische Factory-Methoden und nicht überladene Konstruktoren für tiefes Kopieren in JavaScript zu verwenden.