Estendi i corsi

La parola chiave extends viene utilizzata nelle dichiarazioni o nelle espressioni di classe per creare un che funge da sottoclasse di un'altra, con la classe principale (a volte chiamata "classe base") che funge da prototipo della classe secondaria (a volte chiamata "sottoclasse" o "classe derivata").

class ParentClass {}
class ChildClass extends ParentClass {}

Object.getPrototypeOf( ChildClass );
> class ParentClass {}

Queste sottoclassi ereditano le proprietà e i metodi della classe padre. Questo consente di estendere la funzionalità di base di una classe per senza sovraccaricare la classe principale per adattarla a ogni possibile caso d'uso, o reimplementando codice con uno scopo simile.

Le classi figlio possono fornire le proprie implementazioni dei metodi ereditati da un corso principale:

class MyClass {
  constructor( myPassedValue ) {
    this.instanceProp = myPassedValue;
  }
  classMethod() {
    console.log( `The value was '${ this.instanceProp }.'`)
  }
}
class ChildClass extends MyClass {
  classMethod() {
    console.log( `The value was '${ this.instanceProp },' and its type was '${ typeof this.instanceProp }.'`)
  }
}

const myParentClassInstance = new MyClass( "My string." );
const mySubclassInstance = new ChildClass( 100 );

myParentClassInstance.classMethod();
> "The value type was 'string.'"

mySubclassInstance.classMethod();
> "The value was '100,' and its type was 'number.'"

Puoi anche richiamare metodi definiti nella classe padre nel contesto della classe secondaria utilizzando super:

class MyClass {
  constructor( myPassedValue ) {
    this.instanceProp = myPassedValue;
  }
  classMethod() {
    console.log( `The value was '${ this.instanceProp }.'`)
  }
}

class ChildClass extends MyClass {
  subclassMethod() {
    super.classMethod();
    console.log( `The value type was '${ typeof this.instanceProp }.'`)
  }
}
const mySubclassInstance = new ChildClass( 100 );

mySubclassInstance.subclassMethod();
> The value was '100.'
> The value type was 'number.'

Come si vede negli esempi precedenti, quando il metodo constructor() viene omesso in contesto di una classe figlio, il costruttore implicito di JavaScript chiama insieme allo stesso insieme di argomenti. Tuttavia, se c'è nella sottoclasse, deve prima chiamare super() insieme a qualsiasi gli argomenti necessari prima di fare riferimento a this.

class MyClass {
  constructor( myPassedValue ) {
    this.instanceProp = myPassedValue;
  }
  classMethod() {
    console.log( `The value was '${ this.instanceProp }.'`)
  }
}

class ChildClass extends MyClass {
    constructor( myPassedValue ) {
        super( myPassedValue );
        this.modifiedProp = myPassedValue + 50;
    }\
    subclassMethod() {
        super.classMethod();
        console.log( `The value type was '${ typeof this.instanceProp }.'`)
    }
}
const mySubclassInstance = new ChildClass( 100 );

mySubclassInstance;
> MyClass { instanceProp: 100, modifiedProp: 150 }

Getter e setter sono metodi speciali usati esclusivamente per recuperare e definire rispettivamente. I metodi definiti utilizzando le parole chiave get e set consentono crei metodi con cui interagire come se fossero statici proprietà.

class MyClass {
    constructor( originalValue ) {
        this.totalValue = 0;
    }
    set doubleThisValue( newValue ) {
        this.totalValue = newValue * 2;
    }
    get currentValue() {
        console.log( `The current value is: ${ this.totalValue }` );
    }
}
const myClassInstance = new MyClass();

myClassInstance;
> MyClass { totalValue: 0 }

myClassInstance.doubleThisValue = 20;

myClassInstance.currentValue;
> The current value is: 40

Le proprietà get e set sono definite nella proprietà prototipo della classe e sono quindi disponibili per tutte le istanze della classe.

Verifica le tue conoscenze

Seleziona le affermazioni vere sulle classi create con la parola chiave extends.

Funge da elemento secondario della classe che estende.

Eredita le proprietà e i metodi della classe principale.

Funge dall'elemento padre della classe che estende.

It can't overwrite methods from a parent class.