Waar zijn getters en setters voor in ECMAScript 6-klassen?

Ik weet niet wat het nut is van getters en setters in ECMAScript 6-klassen. Wat is het doel? Hieronder is een voorbeeld waarnaar ik verwijs:

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;
        }
    }
}

Antwoord 1, autoriteit 100%

Met deze setter en getter kunt u de eigenschappen rechtstreeks gebruiken (zonder de haakjes te gebruiken)

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

Dit is alleen om de waarde van de eigenschap in te stellen en te verkrijgen.

Antwoord 2, autoriteit 46%

Getters en setters in ES6 hebben hetzelfde doel als in andere talen… inclusief ES5. ES5 staat al getters en setters toe via Object.defineProperty, hoewel ze minder schoon en omslachtiger in gebruik zijn.

In feite stellen getters en setters je in staat om standaard eigenschapstoegangsnotatie te gebruiken voor lezen en schrijven, terwijl je nog steeds de mogelijkheid hebt om aan te passen hoe de eigenschap wordt opgehaald en gemuteerd zonder de benodigde expliciete getter- en setter-methoden.

In de klasse Werknemer hierboven zou dit betekenen dat u als volgt toegang krijgt tot de eigenschap name:

console.log(someEmployee.name);

Het zou eruit zienals een normale eigendomstoegang, maar het zou in feite toUpperCaseaanroepen op de naam voordat het wordt geretourneerd. Op dezelfde manier doet u dit:

someEmployee.name = null;

zou toegang krijgen tot de setter en het zou de interne eigenschap _nameniet wijzigen vanwege de guard-clausule die is geïntroduceerd in de setter van name.

Zie ook de algemene vraag Waarom getters en setters gebruiken?voor meer informatie over waarom het nuttig is om de functionaliteit van ledentoegang te wijzigen.

Antwoord 3, autoriteit 8%

class Employee {
    constructor(name) {
      this._name = name;
    }
    doWork() {
      return `${this._name} is working`;
    }
    get name() {
      // when you get this by employeeInstance.name
      // 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 below 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 successful, because the `if check`
  console.log(employeeInstance.name)
  // => 
  // get triggered
  // set triggered
  // get triggered
  // MIKE

Hoe dan ook, de getteren setteris net als een spion. Het bespioneert de eigenschap van een object, zodat u iets kunt doen, elke keer dat u de waarde van de eigenschap krijgt of instelt.

Antwoord 4, autoriteit 4%

ES6 getters en setters hebben een wezenlijk andere motivatie dan vergelijkbare concepten in Java.

In Java laten getters en setters een klasse toe om een ​​JavaBean te definiëren. Het punt van getters en setters is dat de boon een volledig orthogonale “interface” kan hebben ten opzichte van die geïmpliceerd door openbare velden. Dus ik kan een veld “naam” hebben dat GEEN JavaBean-eigenschap is, en ik kan een JavaBean-eigenschap “adres” hebben dat GEEN veld is.

JavaBean-eigenschappen zijn ook “vindbaar” door duizenden frameworks (bijvoorbeeld Hibernate) via Java-reflectie. Getters en setters maken dus deel uit van een standaardmethode voor het “belichten” van boneneigenschappen.

Getters en setters, die functies zijn, hebben ook de waarde dat ze de implementatie “abstracteren”. Het kan OFWEL een veld zijn of een berekende (“synthetische”) waarde. Dus als ik een bean-eigenschap heb met de naam “zipcode”, begint dat als een opgeslagen tekenreeks. Stel nu dat ik het wil veranderen in een waarde berekend op basis van adres/stad/staat?

Als ik een veld gebruik, breekt deze code:

     String zipcode = address.zipcode();

Maar als ik een getter gebruik, breekt dit niet:

     String zipcode = address.getZipcode();

JavaScript heeft niet zoiets als JavaBeans. Voor zover ik heb gelezen, is de beoogde waarde van GET en SET beperkt tot de bovengenoemde “synthetische” (berekende) eigenschappen.

Maar het is iets beter dan java omdat Java je niet toestaat om een ​​”veld” compatibel te converteren naar een methode, maar ES6 GET en SET dat wel toelaten.

Dat wil zeggen, als ik:

      var zipcode = address.zipcode;

Als ik de postcode verander van een standaard objecteigenschap naar een getter, roept de bovenstaande code nu de GET-functie aan.

Merk op dat als ik GET niet in de definitie zou opnemen, dit GEEN beroep zou doen op de postcode GET-methode. In plaats daarvan zou het alleen de functie postcode toewijzen aan de var.

Dus ik denk dat dit enkele belangrijke verschillen zijn om te begrijpen tussen Java en JavaScript ES6 getters en setters.