Wofür sind Getter und Setter in ECMAScript 6-Klassen?

Ich bin verwirrt darüber, wozu Getter und Setter in ECMAScript 6-Klassen gut sind. Was ist der Zweck? Unten ist ein Beispiel, auf das ich mich beziehe:

class Employee {

    constructor(name) {
        this._name = name;
    }

    doWork() {
        return `${this._name} is working`;
    }

    get name() {
        return this._name.toUpperCase();
    }

    set name(newName){
        if(newName){ 
            this._name = newName;
        }
    }
}

Mit diesem Setter und Getter können Sie die Eigenschaften direkt verwenden (ohne die Klammer zu verwenden).

var emp = new Employee("TruMan1");

if (emp.name) { 
  // uses the get method in the background
}

emp.name = "New name"; // uses the setter in the background

Dies dient nur zum Festlegen und Abrufen des Werts der Eigenschaft.

Getter und Setter in ES6 dienen demselben Zweck wie in anderen Sprachen ... einschließlich ES5. ES5 erlaubt Getter und Setter bereits über Object.defineProperty, obwohl sie weniger sauber und umständlicher zu bedienen sind.

Getter und Setter ermöglichen es Ihnen effektiv, die Standardnotation für den Zugriff auf Eigenschaften für Lese- und Schreibvorgänge zu verwenden, während Sie dennoch anpassen können, wie die Eigenschaft abgerufen und mutiert wird, ohne dass explizite Getter- und Setter-Methoden erforderlich sind.

In der obigen Mitarbeiterklasse bedeutet dies, dass Sie wie folgt auf die nameEigenschaft zugreifen können:

console.log(someEmployee.name);

Es würde wie ein normaler Eigenschaftszugriff aussehen , aber es würde tatsächlich toUpperCaseden Namen aufrufen, bevor es zurückgegeben wird. In ähnlicher Weise:

someEmployee.name = null;

würde auf den Setter zugreifen und die interne _nameEigenschaft aufgrund der in nameSetter eingeführten Schutzklausel nicht ändern .

Siehe auch die allgemeine Frage Warum Getter und Setter verwenden? Weitere Informationen dazu, warum es hilfreich ist, die Funktionalität des Mitgliederzugriffs zu ändern.

ES6-Getter und -Setter haben eine wesentlich andere Motivation als ähnliche Konzepte in Java.

In Java ermöglichen Getter und Setter einer Klasse, eine JavaBean zu definieren. Der Punkt von Gettern und Setzern ist, dass die Bean eine vollständig orthogonale "Schnittstelle" von der durch öffentliche Felder implizierten haben kann. Ich kann also ein Feld "name" haben, das KEINE JavaBean-Eigenschaft ist, und ich kann eine JavaBean-Eigenschaft "address" haben, die KEIN Feld ist.

JavaBean-Eigenschaften können auch von Tausenden von Frameworks (z. B. Hibernate) über Java Reflection "entdeckt" werden. Daher sind Getter und Setter Teil einer Standardmethode zum "Freilegen" von Bohneneigenschaften.

Getter und Setter haben als Funktionen auch den Wert, dass sie die Implementierung "abstrahieren". Es kann entweder ein Feld oder ein berechneter ("synthetischer") Wert sein. Wenn ich also eine Bean-Eigenschaft namens "Postleitzahl" habe, beginnt diese als gespeicherte Zeichenfolge. Angenommen, ich möchte es in einen Wert ändern, der aus Adresse / Stadt / Bundesland berechnet wird.

Wenn ich ein Feld verwende, wird dieser Code unterbrochen:

      String zipcode = address.zipcode();

Aber wenn ich einen Getter benutze, bricht das nicht:

      String zipcode = address.getZipcode();

JavaScript hat nichts wie JavaBeans. Soweit ich gelesen habe, ist der beabsichtigte Wert von GET und SET auf die oben genannten "synthetischen" (berechneten) Eigenschaften beschränkt.

Aber es ist etwas besser als Java, da Java es Ihnen nicht erlaubt, ein "Feld" kompatibel in eine Methode zu konvertieren, ES6 GET und SET dies jedoch zulassen.

Das heißt, wenn ich habe:

       var zipcode = address.zipcode;

Wenn ich die Postleitzahl von einer Standardobjekteigenschaft in einen Getter ändere, ruft der obige Code jetzt die GET-Funktion auf.

Beachten Sie, dass wenn ich GET nicht in die Definition aufgenommen hätte, dies NICHT die Postleitzahl-GET-Methode aufrufen würde. Stattdessen würde es lediglich die Postleitzahl der Funktion der var zuweisen.

Daher denke ich, dass dies einige wichtige Unterscheidungen sind, um zwischen Java- und JavaScript ES6-Get- und -Setzern zu verstehen.

class Employee {

    constructor(name) {
      this._name = name;
    }

    doWork() {
      return `${this._name} is working`;
    }

    get name() {
      // when you get this by employeeInstance.mame
      // the code below will be triggered
      // and you can do some logic here
      // just like `console.log` something you want
      console.log('get triggered!')
      return this._name.toUpperCase();
    }

    set name(newName) {
      // the same as `get`
      // when you employeeInstance.mame = 'xxx'
      // the code blew will be trigged
      // and you can also do some logic 
      // like here is a `console.log` and `if check`
      console.log('set triggered!')
      if (newName) {
        this._name = newName;
      }
    }
  }

  const employeeInstance = new Employee('mike')
  employeeInstance.name
  employeeInstance.name = '' // this won't be success, because the `if check`
  console.log(employeeInstance.name)

  // => 
  // get triggered
  // set triggered
  // get triggered
  // MIKE

Jedenfalls ist das getterund setterwie ein Spion. Es erkennt die Eigenschaft eines Objekts, sodass Sie jedes Mal etwas tun können, wenn Sie den Wert der Eigenschaft abrufen oder festlegen.