Ein Artikel bringt Ihnen die Vererbung von JS-Funktionen bei

 // Übergeordnete Funktion Person
  Funktion Person(Name, Alter) {
    // Definieren Sie einige Eigenschaften this.name = name;
    dieses.Alter = Alter;
    this.nature = ["Polarlichter", "Wind", "Mond"];
  }
 // Definieren Sie eine Methode für den Personenprototyp Person.prototype.sayLove = function () {
    console.log(dieser.name + " like " + diese.nature[0]);
  };
  // Unterfunktion Jack
  Funktion Jack() {}
  // Die Instanz der übergeordneten Klasse wird als Prototyp der untergeordneten Klasse verwendet (-------------------Implementierungskern--------------------------)
  Jack.prototype = neue Person();

      var jack1 = neuer Jack();
      var jack2 = neuer Jack();
      jack2.nature[0] = "Meer";
      jack1.sayLove();
      jack2.sayLove();   
      Konsole.log(jack1.nature);
      Konsole.log(jack2.nature);  

 // Übergeordnete Funktion Person
  Funktion Person(Name, Alter) {
    // Definieren Sie einige Eigenschaften this.name = name;
    dieses.Alter = Alter;
    this.nature = ["Polarlichter", "Wind", "Mond"];
  }
 // Definieren Sie eine Methode für den Personenprototyp Person.prototype.sayLove = function () {
    console.log(dieser.name + " like " + diese.nature[0]);
  };
  // Unterfunktion Lucy
  Funktion Lucy(Name, Alter) {
  // Dies durch einen Aufruf auf Lucy zu verweisen, ist gleichbedeutend mit dem Kopieren des Inhalts in der übergeordneten Funktion Person (---------Implementierungskern--------------)
        Person.call(dies, Name, Alter);
      }
  // Definieren Sie eine Methode für den Prototyp der untergeordneten Funktion Lucy.prototype.syaName = function () {
        console.log("Mein Name ist " + dieser.name);
      };

      var lucy1 = neue Lucy("lucy1", "20");
      var lucy2 = neue Lucy("lucy2", "22");
      lucy2.nature[0] = "Meer";
      Konsole.log(lucy1.name);
      Konsole.log(lucy1.nature);
      Konsole.log(lucy2.nature);
      lucy1.syaName();
      lucy2.syaName();
      lucy1.sayLove();

 // Übergeordnete Funktion Person
  Funktion Person(Name, Alter) {
    // Definieren Sie einige Eigenschaften this.name = name;
    dieses.Alter = Alter;
    this.nature = ["Polarlichter", "Wind", "Mond"];
  }
 // Definieren Sie eine Methode für den Personenprototyp Person.prototype.sayLove = function () {
    console.log(dieser.name + " like " + diese.nature[0]);
  };
  // Unterfunktion Lisa
      Funktion Lisa(Name, Alter) {
// Dies durch einen Aufruf an Lisa zu verweisen, ist gleichbedeutend mit dem Kopieren des Inhalts in der übergeordneten Funktion Person (------Implementierungskern-----------)      
        Person.call(dies, Name, Alter);
      }
// Die Instanz der übergeordneten Klasse wird als Prototyp der untergeordneten Klasse verwendet. (---------------Implementierungskern-------------------)      
      Lisa.prototype = neue Person();
  // Ein kleiner Wissenspunkt: Hier soll Lisas Konstruktor erneut auf Lisa zeigen. Andernfalls zeigt der Konstruktor auf Person, da Lisas Prototyp eine Person-Instanz ist
      Lisa.prototype.constructor = Lisa;

      var lisa1 = neue Lisa("lisa1", "20");
      var lisa2 = neue Lisa("lisa2", "21");
      lisa2.nature[0] = "Meer";
      console.log(lisa1.name);
      Konsole.log(lisa1.nature);
      Konsole.log(lisa2.nature);
      lisa1.sayLove();
      lisa2.sayLove();

 // Übergeordnete Funktion Person
  Funktion Person(Name, Alter) {
    // Definieren Sie einige Eigenschaften this.name = name;
    dieses.Alter = Alter;
    this.nature = ["Polarlichter", "Wind", "Mond"];
  }
 // Definieren Sie eine Methode für den Personenprototyp Person.prototype.sayLove = function () {
    console.log(dieser.name + " like " + diese.nature[0]);
  };
  // Unterfunktion Andy
 Funktion Andy(Name, Alter) {
        Person.call(dies, Name, Alter);
      }
// Wenn keine Methode Object.create() vorhanden ist, kapseln Sie einfach if (!Object.create) {
        Objekt.erstellen = Funktion (Proto) {
          Funktion Temp() {}
          Temp. Prototyp = Prototyp;
          gib neue Temperatur zurück();
        };
      }
// Rufen Sie die Methode Object.create auf, um ein neues Bildpaar zu erstellen, dessen __proto__ Person.prototype ist, und weisen Sie es Andy.prototype zu (----------Implementierungskern----------)
      Andy.prototype = Objekt.erstellen(Person.prototype);
  //Ändern Sie den Konstruktor, sodass er auf Andy.prototype.constructor = Andy verweist.

      Konsole.log(Andy.prototype.__proto__ === Person.prototype);
      var andy1 = neuer Andy("andy1", "20");
      var andy2 = neuer Andy("andy2", "21");
      andy2.nature[0] = "Meer";
      console.log(andy1.name);
      Konsole.log(andy1.nature);
      Konsole.log(andy2.nature);
      andy1.sayLove();
      andy2.sayLove();

//Definiere eine übergeordnete Klasse Animal
  Klasse Tier {
   //Hier zeigt der Konstruktor auf die Klasse selbst, genauso wie beim Verhalten von es5 constructor(name) {
      dieser.name = Name;
    }
    wieEssen() {
      console.log(dieser.Name + " wie essen " + dieses.Essen);
    }
  }
//Definieren Sie eine Unterklasse Dog, die die übergeordnete Klasse Animal durch Erweiterungen erbt.
  Klasse Hund erweitert Tier {   
    Konstruktor(Name, Essen) {
      //Erbe das Attribut super(name) der übergeordneten Klasse durch super(attribute name);
     dieses.Essen = Essen;
    }
    wieEssen() {
     //Erbe die Methode der übergeordneten Klasse durch super.+Methode der übergeordneten Klasse super.likeEat();
    }
  }

  var jinmao = neuer Hund("jinmao", "Knochen");
  Konsole.log(jinmao.name);
  jinmao.likeEat();