Erstellung von JAVASCRIPT-Objekten und Verständnis und Vorstellung von 6 Vererbungsmodi

In JS gibt es insgesamt sechs Vererbungsmuster, darunter Prototypenkette, geliehener Konstruktor, kombinierte Vererbung, prototypische Vererbung, parasitäre Vererbung und parasitäre kombinierte Vererbung. Um das Verständnis und das Gedächtnis zu erleichtern, habe ich mir einen Prozess vorgestellt und die 6 Modi kurz erklärt.

Es ist eine sehr lange Geschichte, nennen wir sie Nuwa Creates Man.

Erstellen von Objekten

Nuwa hat Menschen (erstellte Objekte) einen nach dem anderen gekniffen, was zu langsam war, also entwarf sie eine Maschine (Funktion), um zu sehen, was sie wollte Erschaffen Sie, sagen Sie ihm, welche Eigenschaften und Funktionen diese Person hat, und die Maschine kann es schaffen. Dies ist das Fabrikmuster (die Verwendung derselben Schnittstelle zum Erstellen von Objekten führt zu einer Menge wiederholtem Code, wodurch eine Funktion (Form) erfunden wird).

Aber es ist auch mühsam, einen Menschen mit einer Maschine zu machen (Erde graben, Schlamm kneten, Augen kneifen, Nase kneifen ...) So entstand die Idee, Nasen und Augen im Voraus zu kneifen Ändern Sie zur Sicherung die Maschine und sagen Sie, welche Art von Augen und Nase die Person hat, die Sie erstellen möchten. Eine solche Maschine kann direkt installiert werden.

Es gibt immer noch Probleme damit, dass jeder, der kneift, laufen kann. Dieser Vorgang ist zu langsam und kann zu Fehlern führen Partei (Funktion Die Methode wird außerhalb des Konstruktors und im globalen Bereich definiert). Der Dritte ist dafür verantwortlich, die Funktion zum Ausführen auf allen Personen zu installieren, die ich kneife, und ich nehme sie und lege sie zur Verwendung auf die Maschine, sodass nicht jedes Mal eine Verarbeitung erforderlich ist. OK, die Leute können laufen, was sehr praktisch ist, aber die gebauten Leute brauchen immer noch N-Funktionen von „Sprung“ und „Gehen“. Dann können wir die Maschine nicht mehr so ​​bauen macht keinen Sinn. Also hat Nuwa (Entwickler) schon früh den Prototypenmodus erstellt ... Mein Wa ist unglaublich.

Jede Funktion im Prototypmodus verfügt über ein Prototypattribut, bei dem es sich um einen Zeiger handelt, der auf das Prototypobjekt zeigt. Das Prototypobjekt enthält Eigenschaften und Methoden, die von allen Instanzen gemeinsam genutzt werden können. Dieses Prototypobjekt verfügt über ein Konstruktorattribut, das einen Zeiger auf die Funktion enthält, in der sich das Prototypattribut befindet.

Es scheint etwas verwirrend, aber aus der Sicht von Nuwa ist es leicht zu verstehen: Die Schöpferin Nuwa hat auch eine Vielzahl von Formen (Prototypenobjekten) erfunden und ist gerade dabei, mit deren Erstellung zu beginnen: 1 Erstellen eine Art Mensch -->Die Form, aus der solche Menschen hergestellt werden, wird verwendet. Schließlich kann alles hergestellt werden, und zwar in welcher Form auch immer. Alle vom Menschen hergestellten Maschinen (Funktionen) haben ihre eigene einzigartige Form (Prototypobjekt), und die Maschine verfügt über eine Beschriftung [Prototyp], die auf die Form verweist. Diese Form verfügt über ein [Konstrukteur]-Attribut, das mit einer Produktionsmarke gekennzeichnet werden kann. zeigt auf diese Maschine und zeigt damit an, dass es sich um eine Maschine handelt, die für die Formenherstellung verwendet wird. Wenn Sie also einen bestimmten Personentyp erschaffen möchten, müssen Sie nur die Form ändern. Dies ist der Vorteil von Prototypobjekten, die bequem und schnell sind.

Der Produktionsprozess ist wie folgt: 1 Erstellen Sie Maschine A: function jqA(){} //Es gibt ein Prototypattribut, das auf die Form (Prototypobjekt) zeigt

2 Erstellen Sie die Form: jqA.prototype={

Konstruktor: jqA, // Äquivalent zur Beschriftung, hergestellt von Maschine A,

Name: 'Lilie',

Haut: 'weiß ',

　　　　　　run: function(){

　　　　　（ Der Schimmel ist für die Entstehung des Namens Lili verantwortlich und die Haut ist weiß, die Art von Menschen, die rennen können.

3 Erstellen Sie eine Person dieses Typs var person1=new jqA();

Erstellen Sie eine Person dieses Typs var person2=new jaA();

person1 und person2 Es gibt ein [[Prototyp]]-Attribut, das bedeutet, dass es von Vorlage A verarbeitet wurde und auf Vorlage A verweist.

Es ist perfekt, aber das Problem tritt erneut auf. Die auf diese Weise erzeugten Personen sind alle gleich . Fünf identische weiße Menschen kommen auf Sie zu, und dann sind da noch fünf kleine, hässliche Menschen mit dem gleichen Aussehen. Während Maschine A also Vorlagen verwendet, kann sie nach den weiblichen Anweisungen auch Menschen mit unterschiedlichen Eigenschaften erstellen, wie zum Beispiel: Dieser hat blaue Augen, dieser ist dicker. . Diese zusätzliche Funktion wird durch den Konstruktor implementiert ---》Verwendung des Konstruktors und des Prototypmusters in Kombination

Der Produktionsprozess ist wie folgt: Vorlage, sodass die Vorlage direkt in der Maschine installiert wird: Initialisieren Sie das Prototypobjekt in der Konstruktor ---" Der dynamische Prototypenmodus ist bequemer

　 Der Produktionsprozess ist wie folgt:

und Frage? Ok, stellen Sie den parasitären Konstruktormodus bereit: Fügen Sie der Maschine eine interne Maschine hinzu, diese interne Maschine ist für die Produktion verantwortlich und stellt die produzierten Personen der externen Maschine zur Verfügung, und die externe Maschine stellt diese Personen der Außenseite zur Verfügung. (Normalerweise nicht verwendet...)

        //组合使用构造函数模式和原型模式
            function  Person(name,skill,country) {
                this.name=name;
                this.age=skill;
                this.country=country;
                this.member=["刘封","刘婵"];
            } //机器可以听命令
 
            Person.prototype={
                constructor:Person,
                sayName:function () {
                    alert(this.name);
                }
            }  //还可以用模板
             var person1=new Person('马超','铁骑','蜀国');
             var person2=new Person('刘备','仁德','蜀国');

Vererbung (nach meinem Verständnis—_—)

　　问题：女娲要造另一批人B，这批人的模板B造好了，但是想让这批人有之前造过的那批人的特点，怎么办？先让这些人过滤一下先前的模板A，在放到B中造就ok,这样类‘B人'就继承了‘A’类人的特点。如何过滤：父实例=子原型 建B的模板，造一个a出来，这个a肯定要过滤A模板，所以让B的模板等于a就ok,问题解决。　

　//父函数，机器A，A类人。它的实例a中有[[Prototype]]属性和自定义的property属性

　　　　function SuperType(){
　　　　this.property=true;
　　　　}
　　　　//在SuperType原型对象(模具A)中添加getSuperValue方法
　　　　SuperType.prototype.getSuperValue=function(){
　　　　return this.property 
　　　　　　}
 
　　　　//子函数，机器B，B类人。构造函数SubType,它的实例中有[[Prototype]]属性和自定义的subproperty属性
　　　　function SubType(){
　　　　this.subproperty=false;
　　　　　　}
　　　　//继承了SuperType （原型链）
　　　　SubType.prototype=new SuperType();  //机器B=a
　　　　//在SubType原型对象（模具B）中添加getSubValue方法
　　　　SubType.prototype.getSubValue=function(){
return tis.subproperty;
　　　　}；　　
　　　　var insatance=new SubType();
　　　　alert(insatance.getSuperValue()); //true

问题：引用类型值会改变，因为实例共享属性，和原型模式中的问题相同

解决方案：经典继承 （借用构造函数）：其实就是把模具A设计到机器B中，但是它已经不是模板了，机器B会给生产的b们添加这些A中的属性和方法，但是可以人为控制，女娲又命令机器B根据传递不同的命令生产不同的b。

　　

在子类构造函数的内部调用超类构造函数

　　　　 相当于把父类的属性实例化到子类中？Java中的super（） 存在疑问

　

　　　function SuperType(){
　　this.colors=['red','blue','green'];
　　　　}
　　　　function SubType(){
　　　　//继承了SuperTYpe
　　　　SuperType.call(this);
　　　　　}
　　　　var insatance1=new SubType();
　　　　insatance1.colors.push('black');
　　　　alert(insatance1.colors);// 'red,blue,green,black'
 
　　　　var insatance2=new SubType();
 　　　alert(insatance2.colors);//'red,blue,green'

1传递参数：

　　　　　　借用构造参数可以在子类型构造参数中向超类型构造参数传递参数

　

　　　　　function SuperType(name){
   this.name=name;
　　　　　　}
　　　　　　function SubType(){
　　　　//继承了SuperTYpe,同时还传递了参数
　　　　SuperType.call(this，'赵云');
 
　　　　//实例属性
　　　　this.age=29；
　　　　}

　　　　var insatance=new SubType();

　　　　alert(insatance.name); //赵云

　　　 alert(insatance.age); //29

为了确保SuperType构造函数不会重写子类型的属性，可以在调用超类型构造函数之后，再添加应该在子类型中定义的属性。

问题：浪费劳动力，在机器中创建A具有的功能和属性，那么A模板就没用了，相当于回到工厂模式，都有打火机了，还要钻木取火吗....

　　解决方案：组合继承

　　　　在公司加班没事做，现在赶着下班，故事编不下去了，后面的继承模式搬之前的记录吧..　　　

　 原型链和构造函数技术组合到一起，使用原型链实现对原型属性和方法的继承，借用构造函数来实现对实例属性的继承。这样通过在原型上定义方法实现了函数的复用，有能够保证每个实例都有它自己的属性

　　　　原型继承：方法可以，实例属性无法继承； 借用构造函数：实例属性可以，方法不行。 一起用，完美。

　　 　　

  function SuperType(name){
　　 this.name=name;
　　 thi.colors=['red','blue','green'];
　　　 　}
　　　　SuperType.prototype.sayName=function(){
　 　alert(this.name);
　　　　};
 
　　　　function SubType(name，age){
　　//继承属性
　　SuperType.call(this,name);
　　this.age=age；
　　　　}
　　　　 //继承方法
 　　SubType.prototype=new SuperType();
 
 　　SubType.prototype.sayAge=function(){
  　　alert(this.age);
　　 }
 
　　var instance1=new SubType('zhaoyun',29);
　　instance1.colors.push('black');
　　alert(instance1.colors); //'red,blue,green,black'
　　instance1.sayName();//zhaoyun
　　instance1.sayAge();//29
 
　　var insatance2=new SubType('诸葛瑾'，25)；
　　alert(instance2.colrs);'red,blue,green'
　　instance22.sayName();//诸葛瑾
　　instance2.sayAge();//25