Eine tägliche Zusammenfassung des Javascript-Lernens (objektorientierte Programmierung)

1. Objektorientierte Fabrikmethode

 function createPerson(name, age, job){
   var o = new Object();
   o.name = name;
   o.age = age;
   o.job = job;
   o.sayName = function(){
    alert(this.name);
   }; 
   return o;
  }
  
  var person1 = createPerson("Nicholas", 29, "Software Engineer");
  var person2 = createPerson("Greg", 27, "Doctor");
  
  person1.sayName(); //"Nicholas"
  person2.sayName(); //"Greg"

Nach dem Login kopieren

Der Nachteil der Factory-Modell-Methode besteht darin, dass sie viel doppelten Code generiert!

2. Konstruktormuster erstellt Objekte

 function Person(name, age, job){
   this.name = name;
   this.age = age;
   this.job = job;
   this.sayName = function(){
    alert(this.name);
   }; 
  }
  
  var person1 = new Person("Nicholas", 29, "Software Engineer");
  var person2 = new Person("Greg", 27, "Doctor");
  
  person1.sayName(); //"Nicholas"
  person2.sayName(); //"Greg"
  
  alert(person1 instanceof Object); //true
  alert(person1 instanceof Person); //true
  alert(person2 instanceof Object); //true
  alert(person2 instanceof Person); //true
  
  alert(person1.constructor == Person); //true
  alert(person2.constructor == Person); //true
  
  alert(person1.sayName == person2.sayName); //false

Nach dem Login kopieren

Die Verwendung des neuen Schlüsselworts zum Erstellen eines Objekts durchläuft die folgenden vier Prozesse

1. Erstellen Sie ein neues Objekt
2. Weisen Sie den Bereich des Konstruktors einem neuen Objekt zu (damit dieser auf dieses neue Objekt zeigt)
3. Methode zum Ausführen des Konstruktors (weisen Sie diesem neuen Objekt einen Wert zu)
4. Neues Objekt zurückgeben

3. Verwenden Sie den Konstruktor als Funktion

 function Person(name, age, job){
   this.name = name;
   this.age = age;
   this.job = job;
   this.sayName = function(){
    alert(this.name);
   };
  }
  
  var person = new Person("Nicholas", 29, "Software Engineer");
  person.sayName(); //"Nicholas"
  
  Person("Greg", 27, "Doctor"); //adds to window
  window.sayName(); //"Greg"
  
  var o = new Object();
  Person.call(o, "Kristen", 25, "Nurse");
  o.sayName(); //"Kristen"

Nach dem Login kopieren

Bei Verwendung als Funktion unterscheidet sich der Konstruktor nicht von einer gewöhnlichen Funktion. Es handelt sich lediglich um eine Methode, die unter dem Fensterobjekt hinzugefügt wird. Da das vom Konstruktor erstellte Objekt tatsächlich ein neues Objekt erstellt, sind die beiden im Wesentlichen unterschiedlich und getrennt, und ihre Methoden sind immer noch unterschiedlich!

4. Verwenden Sie gängige Methoden, um inkonsistente Probleme global zu lösen

 function Person(name, age, job){
   this.name = name;
   this.age = age;
   this.job = job;
   this.sayName = sayName;
  }
  
  function sayName(){
   alert(this.name);
  }
  
  var person1 = new Person("Nicholas", 29, "Software Engineer");
  var person2 = new Person("Greg", 27, "Doctor");
  
  person1.sayName(); //"Nicholas"
  person2.sayName(); //"Greg"
  
  alert(person1 instanceof Object); //true
  alert(person1 instanceof Person); //true
  alert(person2 instanceof Object); //true
  alert(person2 instanceof Person); //true
  
  alert(person1.constructor == Person); //true
  alert(person2.constructor == Person); //true
  
  alert(person1.sayName == person2.sayName); //true

Nach dem Login kopieren

Obwohl die obige Methode das gleiche Problem löst, gehört die definierte globale Methode selbst zum Fenster, sodass es keine Trennung zwischen lokal und global gibt! Daher wird diese Methode selten angewendet! Auch nicht zu empfehlen.

5. Prototypenmodus

Jede von uns erstellte Funktion verfügt über ein Prototypobjekt. Dieses Attribut ist ein Zeiger, der auf ein Objekt zeigt, und die Funktion dieses Objekts besteht darin, Methoden zu haben, die von allen Instanzen eines bestimmten Typs gemeinsam genutzt werden können!

 function Person(){
  }
  
  Person.prototype.name = "Nicholas";
  Person.prototype.age = 29;
  Person.prototype.job = "Software Engineer";
  Person.prototype.sayName = function(){
   alert(this.name);
  };
  
  var person1 = new Person();
  person1.sayName(); //"Nicholas"
  
  var person2 = new Person();
  person2.sayName(); //"Nicholas"
  
  alert(person1.sayName == person2.sayName); //true
  
  alert(Person.prototype.isPrototypeOf(person1)); //true
  alert(Person.prototype.isPrototypeOf(person2)); //true
  
  //only works if Object.getPrototypeOf() is available
  if (Object.getPrototypeOf){
   alert(Object.getPrototypeOf(person1) == Person.prototype); //true
   alert(Object.getPrototypeOf(person1).name); //"Nicholas"
  }

Nach dem Login kopieren

Prototypen verstehen

Immer wenn eine Funktion erstellt wird, wird eine Prototypeigenschaft erstellt, die auf das Prototypobjekt der Funktion verweist. Standardmäßig enthält das Prototypobjekt einen Konstruktor (Konstruktorattribut), der einen Zeiger auf die Funktion enthält, in der sich das Prototypattribut befindet!

Die Reihenfolge des Attributlesens

Jedes Mal, wenn der Code die Eigenschaften eines Objekts liest, führt er eine Suche durch. Das Ziel ist die Eigenschaft mit dem angegebenen Namen. Die Suche beginnt bei der Instanz des Objekts selbst Wenn nicht, wird die Suche nach dem Objekt fortgesetzt, bis die äußerste Schicht der Prototypenkette durchsucht ist.

 function Person(){
  }
  
  Person.prototype.name = "Nicholas";
  Person.prototype.age = 29;
  Person.prototype.job = "Software Engineer";
  Person.prototype.sayName = function(){
   alert(this.name);
  };
  
  var person1 = new Person();
  var person2 = new Person();
  
  person1.name = "Greg";
  alert(person1.name); //"Greg" 来自实例
  alert(person2.name); //"Nicholas" 来自原型

Nach dem Login kopieren

Wenn das Instanzattribut dieses Elements gelöscht wird

function Person(){
  }
  
  Person.prototype.name = "Nicholas";
  Person.prototype.age = 29;
  Person.prototype.job = "Software Engineer";
  Person.prototype.sayName = function(){
   alert(this.name);
  };
  
  var person1 = new Person();
  var person2 = new Person();
  
  person1.name = "Greg";
  alert(person1.name); //"Greg" &#63;from instance
  alert(person2.name); //"Nicholas" &#63;from prototype
  
  delete person1.name;
  alert(person1.name); //"Nicholas" - from the prototype

Nach dem Login kopieren

6. hasOwnProperty-Methode

Diese Methode kann erkennen, ob eine Eigenschaft in der Instanz oder im Prototyp vorhanden ist! hasOwnProperty wird von Object geerbt und gibt true zurück, solange die angegebene Eigenschaft in der Objektinstanz vorhanden ist.

 function Person(){
    }
    
    Person.prototype.name = "Nicholas";
    Person.prototype.age = 29;
    Person.prototype.job = "Software Engineer";
    Person.prototype.sayName = function(){
      alert(this.name);
    };
    
    var person1 = new Person();
    var person2 = new Person();
    
    alert(person1.hasOwnProperty("name")); //false
    alert("name" in person1); //true
    
    person1.name = "Greg";
    alert(person1.name);  //"Greg" &#63;from instance
    alert(person1.hasOwnProperty("name")); //true
    alert("name" in person1); //true
    
    alert(person2.name);  //"Nicholas" &#63;from prototype
    alert(person2.hasOwnProperty("name")); //false
    alert("name" in person2); //true
    
    delete person1.name;
    alert(person1.name);  //"Nicholas" - from the prototype
    alert(person1.hasOwnProperty("name")); //false
    alert("name" in person1); //true

Nach dem Login kopieren

7. Aufzählbare Eigenschaftsmethode Object.keys()

Diese Methode empfängt ein Objekt als Parameter und gibt ein String-Array zurück, das alle aufzählbaren Eigenschaften enthält

 function Person(){
    }
    
    Person.prototype.name = "Nicholas";
    Person.prototype.age = 29;
    Person.prototype.job = "Software Engineer";
    Person.prototype.sayName = function(){
      alert(this.name);
    };
    
    var keys = Object.keys(Person.prototype);
    alert(keys);  //"name,age,job,sayName"
如果想得到所有实例的属性，无论它是否可以枚举都可以使用这个方法来获取
 function Person(){
    }
    
    Person.prototype.name = "Nicholas";
    Person.prototype.age = 29;
    Person.prototype.job = "Software Engineer";
    Person.prototype.sayName = function(){
      alert(this.name);
    };
    
    var keys = Object.getOwnPropertyNames(Person.prototype);
    alert(keys);  //"constructor,name,age,job,sayName"

Nach dem Login kopieren

Diese Methode wird nur von Browsern höherer Versionen unterstützt

8. Einfache Prototyp-Schreibmethode

 function Person(){
    }
    
    Person.prototype = {
      name : "Nicholas",
      age : 29,
      job: "Software Engineer",
      sayName : function () {
        alert(this.name);
      }
    };

    var friend = new Person();
    
    alert(friend instanceof Object); //true
    alert(friend instanceof Person); //true
    alert(friend.constructor == Person); //false
    alert(friend.constructor == Object); //true

Nach dem Login kopieren

Das Umschreiben des Prototyps entspricht dem Überschreiben der Standard-Prototypmethode. Dann wird dieselbe Konstruktionsmethode auch neu geschrieben und die umgeschriebene Konstruktionsmethode zeigt auf das Objektobjekt! Anstelle des ursprünglichen Objekts Person

Wenn Sie weiterhin auf den vorherigen Konstruktor verweisen möchten, können Sie ihn explizit angeben

 function Person(){
    }
    
    Person.prototype = {
      constructor : Person,
      name : "Nicholas",
      age : 29,
      job: "Software Engineer",
      sayName : function () {
        alert(this.name);
      }
    };

    var friend = new Person();
    
    alert(friend instanceof Object); //true
    alert(friend instanceof Person); //true
    alert(friend.constructor == Person); //true
    alert(friend.constructor == Object); //false

Nach dem Login kopieren

9. Dynamisches Hinzufügen von Prototypmethoden

function Person(){
    }
    
    Person.prototype = {
      constructor: Person,
      name : "Nicholas",
      age : 29,
      job : "Software Engineer",
      sayName : function () {
        alert(this.name);
      }
    };
    
    var friend = new Person();
    
    Person.prototype.sayHi = function(){
      alert("hi");
    };
    
    friend.sayHi();  //"hi" &#63;works!

Nach dem Login kopieren

10. Prototypmethoden nativer Objekte

alert(typeof Array.prototype.sort);     //"function"
    alert(typeof String.prototype.substring);  //"function"

    String.prototype.startsWith = function (text) {//修改原生对象的原型方法
      return this.indexOf(text) == 0;
    };
    
    var msg = "Hello world!";
    alert(msg.startsWith("Hello"));  //true

Nach dem Login kopieren

11. Erstellen Sie Objekte mit einer Kombination aus Konstruktoren und Prototypmustern

//构造函数模式
function Person(name, age, job){
      this.name = name;
      this.age = age;
      this.job = job;
      this.friends = ["Shelby", "Court"];
    }
    //原型模式
    Person.prototype = {
      constructor: Person,
      sayName : function () {
        alert(this.name);
      }
    };
    
    var person1 = new Person("Nicholas", 29, "Software Engineer");
    var person2 = new Person("Greg", 27, "Doctor");
    
    person1.friends.push("Van");
    
    alert(person1.friends);  //"Shelby,Court,Van"
    alert(person2.friends);  //"Shelby,Court"
    alert(person1.friends === person2.friends); //false
    alert(person1.sayName === person2.sayName); //true

Nach dem Login kopieren

12. Dynamischer Prototypenmodus

function Person(name, age, job){
    
      //properties
      this.name = name;
      this.age = age;
      this.job = job;
      
      //methods
      if (typeof this.sayName != "function"){
      
        Person.prototype.sayName = function(){
          alert(this.name);
        };
        
      }
    }

    var friend = new Person("Nicholas", 29, "Software Engineer");
    friend.sayName();

Nach dem Login kopieren

13. Parasitäres Konstruktormuster

 function Person(name, age, job){
var o = new Object();//依赖全局对象初始化一个对象，然后再返回这个对象
o.name = name;
o.age = age;
o.job = job;
o.sayName = function(){
alert(this.name);
}; 
return o;
}

var friend = new Person("Nicholas", 29, "Software Engineer");
friend.sayName(); //"Nicholas"

function SpecialArray(){ 

//create the array
var values = new Array();

//add the values
values.push.apply(values, arguments);

//assign the method
values.toPipedString = function(){
return this.join("|");
};

//return it
return values; 
}

var colors = new SpecialArray("red", "blue", "green");
alert(colors.toPipedString()); //"red|blue|green"

alert(colors instanceof SpecialArray);

Nach dem Login kopieren

Eine kleine Erklärung für die Berufungsmethode: Da sie zum Erstellen eines neuen Objekts auf dem äußeren Objekt basiert, kann sie sich nicht auf die Instanzmethode verlassen, um die Quelle von Eigenschaften und Methoden zu bestimmen! Es hat eigentlich nichts mit dem Konstruktor zu tun!

14. Sicheres Konstruktormuster

 function Person(name, age, job){
      var o = new Object();
      o.sayName = function(){
        alert(name);
      };  
      return o;
    }
    
    var friend = Person("Nicholas", 29, "Software Engineer");
    friend.sayName(); //"Nicholas"

Nach dem Login kopieren

Diese Methode basiert nicht auf dem Schlüsselwort new this! Wenn Sie auf die Methoden und Eigenschaften eines Objekts zugreifen möchten, können Sie diese nur über die Methoden erhalten, die das Objekt definiert hat!

15. Vererbung
Javascript implementiert die Vererbung über die Prototypenkette

function SuperType(){
      this.property = true;//定义一个属性
    }
    
    SuperType.prototype.getSuperValue = function(){//定义的原型方法
      return this.property;
    };
    
    function SubType(){
      this.subproperty = false;
    }
    
    //inherit from SuperType
    SubType.prototype = new SuperType();
    
    SubType.prototype.getSubValue = function (){
      return this.subproperty;
    };
    
    var instance = new SubType();
    alert(instance.getSuperValue());  //true
    
    alert(instance instanceof Object);   //true
    alert(instance instanceof SuperType);  //true
    alert(instance instanceof SubType);   //true

    alert(Object.prototype.isPrototypeOf(instance));  //true
    alert(SuperType.prototype.isPrototypeOf(instance)); //true
    alert(SubType.prototype.isPrototypeOf(instance));  //true
SubType继承SuperType的方法和属性，因此当instance可以直接调用SuperType的方法！
 function SuperType(){
      this.property = true;
    }
    
    SuperType.prototype.getSuperValue = function(){
      return this.property;
    };
    
    function SubType(){
      this.subproperty = false;
    }
    
    //inherit from SuperType
    SubType.prototype = new SuperType();
    
    //new method
    SubType.prototype.getSubValue = function (){
      return this.subproperty;
    };
    
    //override existing method
    SubType.prototype.getSuperValue = function (){
      return false;
    };
    
    var instance = new SubType();
    alert(instance.getSuperValue());  //false

Nach dem Login kopieren

Das obige Beispiel zeigt, dass der überschriebene Prototyp den zuvor geerbten Prototyp überschreibt und das zurückgegebene Endergebnis oft nicht den erwarteten Effekt hat

 function SuperType(){
      this.property = true;
    }
    
    SuperType.prototype.getSuperValue = function(){
      return this.property;
    };
    
    function SubType(){
      this.subproperty = false;
    }
    
    //inherit from SuperType
    SubType.prototype = new SuperType();
    
    //使用字面量添加的方法导致上面的方法失效了
    SubType.prototype = {
      getSubValue : function (){
        return this.subproperty;
      },
    
      someOtherMethod : function (){
        return false;
      }
    }; 
    
    var instance = new SubType();
    console.log(instance);
    alert(instance.getSuperValue());  //error!

Nach dem Login kopieren

Das folgende Beispiel verdeutlicht auch die Risiken des Umschreibens von Prototypen

 function SuperType(){
      this.colors = ["red", "blue", "green"];
    }

    function SubType(){      
    }
    
    //inherit from SuperType
    SubType.prototype = new SuperType();

    var instance1 = new SubType();
    instance1.colors.push("black");
    alert(instance1.colors);  //"red,blue,green,black"
    
    var instance2 = new SubType();
    alert(instance2.colors);  //"red,blue,green,black"

Nach dem Login kopieren

原型共享导致两个不同的对象调用的同一个数据
16、借用构造函数来实现继承

 function SuperType(){
      this.colors = ["red", "blue", "green"];
    }

    function SubType(){ 
      //inherit from SuperType
      SuperType.call(this);
    }

    var instance1 = new SubType();
    instance1.colors.push("black");
    alert(instance1.colors);  //"red,blue,green,black"
    
    var instance2 = new SubType();
    alert(instance2.colors);  //"red,blue,green"

Nach dem Login kopieren

传递参数

 function SuperType(name){
      this.name = name;
    }

    function SubType(){ 
      //inherit from SuperType passing in an argument
      SuperType.call(this, "Nicholas");
      
      //instance property
      this.age = 29;
    }

    var instance = new SubType();
    alert(instance.name);  //"Nicholas";
    alert(instance.age);   //29

Nach dem Login kopieren

17、组合继承方式

function SuperType(name){
      this.name = name;
      this.colors = ["red", "blue", "green"];
    }
    
    SuperType.prototype.sayName = function(){
      alert(this.name);
    };

    function SubType(name, age){ 
      SuperType.call(this, name);
      
      this.age = age;
    }

Nach dem Login kopieren

18、原型继承

 function object(o){
      function F(){}
      F.prototype = o;
      return new F();
    }
    
    var person = {
      name: "Nicholas",
      friends: ["Shelby", "Court", "Van"]
    };
    
    var anotherPerson = object(person);
    anotherPerson.name = "Greg";
    anotherPerson.friends.push("Rob");

Nach dem Login kopieren

19、寄生组合式继承

 function object(o){
      function F(){}
      F.prototype = o;
      return new F();
    }
  
    function inheritPrototype(subType, superType){
      var prototype = object(superType.prototype);  //create object
      prototype.constructor = subType;        //augment object
      subType.prototype = prototype;         //assign object
    }
                
    function SuperType(name){
      this.name = name;
      this.colors = ["red", "blue", "green"];
    }
    
    SuperType.prototype.sayName = function(){
      alert(this.name);
    };

    function SubType(name, age){ 
      SuperType.call(this, name);
      
      this.age = age;
    }

    inheritPrototype(SubType, SuperType);
    
    SubType.prototype.sayAge = function(){
      alert(this.age);
    };
    
    var instance1 = new SubType("Nicholas", 29);
    instance1.colors.push("black");
    alert(instance1.colors); //"red,blue,green,black"
    instance1.sayName();   //"Nicholas";
    instance1.sayAge();    //29
    
    
    var instance2 = new SubType("Greg", 27);
    alert(instance2.colors); //"red,blue,green"
    instance2.sayName();   //"Greg";
    instance2.sayAge();    //27

Nach dem Login kopieren

以上就是今天的javascript学习小结，之后每天还会继续更新，希望大家继续关注。

Eine tägliche Zusammenfassung des Javascript-Lernens (objektorientierte Programmierung)_Javascript-Kenntnisse