Comprendre cela et Super en Typescript

Dans Typescript, this et super sont des mots-clés utilisés en programmation orientée objet pour faire référence respectivement à l'instance actuelle d'une classe et à la classe de base.

Ce mot-clé

Définition : Fait référence à l'instance actuelle de la classe.
Cas d'utilisation :

• Accéder aux propriétés et méthodes de l'instance.
• Appelez une autre méthode au sein de la même classe.
• Passer l'objet actuel comme argument

class Pizza {
    name: string

    constructor(name: string){
        this.name = name;
    }

    cook():void{
        console.log(`Start cooking ${this.name} pizza`)
    }
}

const pepperoniPizza = new Pizza("pepperoni");
pepperoniPizza.cook();

super mot-clé

• Définition : Fait référence à la classe de base (la classe parent) de la classe actuelle.
• Cas d'utilisation :
  • Appelez le constructeur de la classe de base.
  • Accéder aux méthodes et propriétés depuis la classe de base

Exemple :

class Animal {
    name: string;

    constructor(name: string) {
      this.name = name;
    }

    makeSound(): void {
      console.log(`${this.name} makes a sound.`);
    }
  }

  class Dog extends Animal {
    constructor(name: string) {
      super(name); // Calls the constructor of the base class
    }

    makeSound(): void {
      super.makeSound(); // Calls the base class method
      console.log(`${this.name} barks.`);
    }
  }

  const dog = new Dog("Buddy");
  dog.makeSound();

et la sortie inclut : makeSound() de la classe de base est Animal et makeSound de la sous-classe est Dog comme ceci :

Buddy makes a sound.
Buddy barks.

Points clés :

1. ceci :

• Toujours faire référence à l'instance actuelle
• Peut être utilisé dans les fonctions constructeur, méthode ou flèche.
• Dans les fonctions fléchées, ceci est lié lexicalement au contexte environnant.

*2. super : *

• Ne peut être utilisé que dans des classes qui prolongent une autre classe.
• Doit être appelé dans le constructeur avant d'y accéder dans une classe dérivée.
• Peut être utilisé pour appeler des méthodes de classe parent.

class Parent {
  protected message: string = "Hello from Parent!";
}

class Child extends Parent {
  showMessage(): void {
    console.log(super.message); // Accesses the parent class property
  }
}

const child = new Child();
child.showMessage(); // Output: Hello from Parent!

En utilisant ceci et super correctement, vous pouvez gérer efficacement l'héritage et le comportement des objets dans Typescript.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!