Was ist ein Konstruktor? Detaillierte Erklärung der Konstruktoren in JavaScript

Als Grundlage für Prototypen und Prototypenketten kann uns das erste Verständnis des Konstruktors und seines Ausführungsprozesses besser dabei helfen, das Wissen über Prototypen und Prototypenketten zu erlernen. In diesem Artikel erfahren Sie mehr über den Konstruktor in JavaScript und stellen vor, wie Sie den Konstruktor zum Erstellen eines JS-Objekts verwenden. Ich hoffe, er wird Ihnen hilfreich sein!

1. Was ist ein Konstruktor?

Wenn eine allgemeine Funktion zum Erstellen eines Klassenobjekts verwendet wird, wird sie als Konstruktor oder Konstruktor bezeichnet. (Zum leichteren Verständnis können Sie die Erstellung von Konstruktoren in JavaScript als die Erstellung von Klassen in anderen Sprachen verstehen. Der Zweck besteht darin, damit ein Objekt durch new zu instanziieren.)

function Person(){
//...
}
//当做普通函数调用
var obj=Person();

//构造函数调用
	 var obj=new Person();

Funktionen des Konstruktors:

• In Schreibkonventionen sind wir es gewohnt, den Anfangsbuchstaben von Konstrukteursnamen groß zu schreiben.

• Erstellen Sie ein Objekt durch Neu.

• Es gibt einen Rückgabewert ohne das Schreiben von return darin, und was zurückgegeben wird, ist ein Objekt.

Verwenden Sie den Konstruktor, um ein js-Objekt zu erstellen

• Der Konstruktor erstellt das Objekt (die Methode wird im Konstruktor geschrieben, Nachteil: Bei jeder Ausführung des Konstruktors wird eine Methode erstellt.)

	  function Person(name,age,gender){
            this.name=name;
            this.age=age;
            this.gender=gender;
            // 方法写在里面
            this.sayName=function(){
                 console.log(this.name);
             }      
          }
    
          function Dog(name,age){
              this.name=name;
              this.age=age;
          }
         
          var obj=new Person("张三",18,"男");
          var obj1=new Person("李四",16,"男");
          
          var dog=new Dog("乐乐",2);
          obj.sayName();
          obj1.sayName();
          
          console.log(obj);
          console.log(obj1);
          console.log(dog);

• Der Konstruktor erstellt das Objekt (die Methode wird außerhalb des Konstruktors geschrieben, Nachteil: Die Methode ist eine globale Methode, die die ganze Welt verschmutzt.)

	   function Person(name,age,gender){
            this.name=name;
            this.age=age;
            this.gender=gender;
            this.sayName=fun;   //方法写在外面
          }
    	 function fun(){
            console.log(this.name);
        }
          function Dog(name,age){
              this.name=name;
              this.age=age;
          }
          
          var obj=new Person("张三",18,"男");
          var obj1=new Person("李四",16,"男");
          
          var dog=new Dog("乐乐",2);
          obj.sayName();
          obj1.sayName();
          
          console.log(obj);
          console.log(obj1);
          console.log(dog);

• Der Konstruktor erstellt das Objekt und transformiert (die Methode wird durch das Prototypobjekt erstellt)

Prototypobjekt: Prototyp

Bei jeder Funktion, die wir erstellen, fügt der Parser der Funktion ein Prototypattribut hinzu.

Zeigt auf das Prototypobjekt des Konstruktors. Auf diese Eigenschaft können wir über __proto__ zugreifen.

Constructor.prototype.xxx, xxx kann eine Variable oder eine Methode sein. Während des Ausführungsprozesses wird zunächst nach Methoden oder Variablen im Objekt gesucht. Wenn diese nicht gefunden werden können, wird im Prototyp danach gesucht.

	  function Person(name,age,gender){
            this.name=name;
            this.age=age;
            this.gender=gender;
          }
          function Dog(name,age){
              this.name=name;
              this.age=age;
          }
          
        /*为person添加统一的方法， 到原型对象中*/
        Person.prototype.sayName=function(){
            console.log(this.name);
        }
          var obj=new Person("张三",18,"男");
          var obj1=new Person("李四",16,"男");
          
          var dog=new Dog("乐乐",2);
          obj.sayName();
          obj1.sayName();
          
          console.log(obj);
          console.log(obj1);
          console.log(dog);

Laufendes Ergebnis:

2. Warum Konstruktor verwenden?

Lernen Sie jedes Konzept kennen und wissen Sie nicht nur, was es ist, sondern auch warum und welche Art von Problem es löst.

Wenn wir beispielsweise die persönlichen Daten jedes Schülers in der ersten Klasse eingeben möchten, können wir einige Objekte erstellen, wie zum Beispiel:

var p1 = { name: 'zs', age: 6, gender: '男', hobby: 'basketball' };
var p2 = { name: 'ls', age: 6, gender: '女', hobby: 'dancing' };
var p3 = { name: 'ww', age: 6, gender: '女', hobby: 'singing' };
var p4 = { name: 'zl', age: 6, gender: '男', hobby: 'football' };
// ...

Wie oben können wir die Informationen jedes Schülers als Objekte behandeln Verfahren. Wir werden jedoch feststellen, dass wir immer wieder viel bedeutungslosen Code schreiben. Wie Name, Alter, Geschlecht, Hobby. Wenn in dieser Klasse 60 Schüler sind, müssen wir es 60 Mal schreiben.

Zu diesem Zeitpunkt spiegeln sich die Vorteile des Konstruktors wider. Wir haben festgestellt, dass jeder Schüler zwar über Attribute wie Name, Geschlecht und Hobby verfügt, diese aber alle unterschiedlich sind. Daher übergeben wir diese Attribute als Parameter des Konstruktors. Und da es sich bei allen um Studienanfänger handelt, liegt ihr Alter grundsätzlich bei 6 Jahren, so dass wir sie aufschreiben und bei besonderen Situationen individuell auf sie eingehen können. An diesem Punkt können wir die folgende Funktion erstellen:

function Person(name, gender, hobby) {
    this.name = name;
    this.gender = gender;
    this.hobby = hobby;
    this.age = 6;
}

Nachdem wir die obige Funktion erstellt haben, können wir sie über das Schlüsselwort new aufrufen, dh das Objekt über den Konstruktor erstellen.

var p1 = new Person('zs', '男', 'basketball');
var p2 = new Person('ls', '女', 'dancing');
var p3 = new Person('ww', '女', 'singing');
var p4 = new Person('zl', '男', 'football');
// ...

An diesem Punkt werden Sie feststellen, dass das Erstellen von Objekten sehr praktisch wird. Obwohl der Prozess der Kapselung des Konstruktors schwieriger ist, ist es für uns nach erfolgreicher Kapselung sehr einfach, Objekte zu erstellen, weshalb wir Konstruktoren verwenden.

Wenn Sie Objektliterale verwenden, um eine Reihe von Objekten desselben Typs zu erstellen, können diese Objekte einige ähnliche Eigenschaften (Eigenschaften) und Verhaltensweisen (Methoden) aufweisen. Zu diesem Zeitpunkt wird viel wiederholter Code generiert, der erreicht werden kann durch die Verwendung von Konstruktoren代码复用 .

3. Der Ausführungsprozess des Konstruktors

Lassen Sie uns zunächst über einige grundlegende Konzepte sprechen.

function Animal(color) {
 this.color = color;
}

Wenn eine Funktion erstellt wird, wissen wir nicht, ob es sich um einen Konstruktor handelt. Selbst wenn der Funktionsname wie im obigen Beispiel in Großbuchstaben geschrieben ist, können wir nicht sicher sein. Erst wenn eine Funktion mit dem Schlüsselwort new aufgerufen wird, können wir sagen, dass es sich um einen Konstruktor handelt. Genau wie das Folgende:

var dog = new Animal("black");

Im Folgenden besprechen wir nur den Ausführungsprozess des Konstruktors, also wenn er mit dem Schlüsselwort new aufgerufen wird.

Nehmen wir die Person oben als Beispiel.

function Person(name, gender, hobby) {
 this.name = name;
 this.gender = gender;
 this.hobby = hobby;
 this.age = 6;
}

var p1 = new Person('zs', '男', 'basketball');

Zu diesem Zeitpunkt verfügt der Konstruktor über die folgenden Ausführungsprozesse:

1) Beim Aufruf mit dem Schlüsselwort new wird ein neuer Speicherplatz erstellt, der als Instanz von Animal gekennzeichnet ist.

2) Dies im Funktionskörper weist auf den Speicher hin

Durch die beiden oben genannten Schritte können wir diese Schlussfolgerung ziehen.

var p2 = new Person('ls', '女', 'dancing');  // 创建一个新的内存 #f2
var p3 = new Person('ww', '女', 'singing');  // 创建一个新的内存 #f3

Immer wenn eine Instanz erstellt wird, wird ein neuer Speicherbereich (#f2, #f3) erstellt. Wenn #f2 erstellt wird, zeigt dieser innerhalb des Funktionskörpers auf #f2, wenn #f3 erstellt wird das deutet auf #f3 hin.

3） 执行函数体内的代码
通过上面的讲解，你就可以知道，给 this 添加属性，就相当于给实例添加属性。

4）默认返回 this

由于函数体内部的this指向新创建的内存空间，默认返回 this ，就相当于默认返回了该内存空间，也就是上图中的 #f1。此时，#f1的内存空间被变量p1所接受。也就是说 p1 这个变量，保存的内存地址就是 #f1，同时被标记为 Person 的实例。

以上就是构造函数的整个执行过程。

4、构造函数的返回值

构造函数执行过程的最后一步是默认返回 this 。言外之意，构造函数的返回值还有其它情况。下面我们就来聊聊关于构造函数返回值的问题。

1）没有手动添加返回值，默认返回 this

function Person1() {
 this.name = 'zhangsan';
}

var p1 = new Person1();

按照上面讲的，我们复习一遍。首先，当用 new 关键字调用时，产生一个新的内存空间 #f11，并标记为 Person1 的实例；接着，函数体内部的 this 指向该内存空间 #f11；执行函数体内部的代码；由于函数体内部的this 指向该内存空间，而该内存空间又被变量 p1 所接收，所以 p1 中就会有一个 name 属性，属性值为 ‘zhangsan’。

p1: {
 name: 'zhangsan'
}

2）手动添加一个基本数据类型的返回值，最终还是返回 this

function Person2() {
 this.age = 28;
 return 50;
}

var p2 = new Person2();
console.log(p2.age);   // 28
p2: {
 age: 28
}

如果上面是一个普通函数的调用，那么返回值就是 50。

3）手动添加一个复杂数据类型(对象)的返回值，最终返回该对象

直接上例子

function Person3() {
 this.height = '180';
 return ['a', 'b', 'c'];
}

var p3 = new Person3();
console.log(p3.height);  // undefined
console.log(p3.length);  // 3
console.log(p3[0]);      // 'a'

再来一个例子

function Person4() {
  this.gender = '男';
  return { gender: '中性' };
}

var p4 = new Person4();
console.log(p4.gender);  // '中性'

5、构造函数首字母必须大写吗？

大小写都可以

6、不用new关键字，直接运行构造函数，是否会出错？

如果不会出错，那么，用new和不用new调用构造函数，有什么区别？

1）使用new操作符调用函数

例子：

function Person(name){
  this.name = name;
  this.say = function(){
    return "I am " + this.name;
  }
}

var person1 = new Person('nicole');
person1.say(); // "I am nicole"

用new调用构造函数，函数内部会发生如下变化：

创建一个this变量，该变量指向一个空对象。并且该对象继承函数的原型；
属性和方法被加入到this引用的对象中；
隐式返回this对象（如果没有显性返回其他对象）
用伪程序来展示上述变化：

function Person(name){
  // 创建this变量，指向空对象
  var this = {}; 
  // 属性和方法被加入到this引用的对象中
  this.name = name;
  this.say = function(){
    return "I am " + this.name;
  }
  // 返回this对象
  return this;
}

可以看出，用new调用构造函数，最大特点为，this对象指向构造函数生成的对象，所以，person1.say()会返回字符串： “I am nicole”。

小贴士：如果指定了返回对象，那么，this对象可能被丢失。

function Person(name){
  this.name = name;
  this.say = function(){
    return "I am " + this.name;
  }
  var that = {};
  that.name = "It is that!";
  return that;
}

var person1 = new Person('nicole');
person1.name; // "It is that!"

2）直接调用函数

如果直接调用函数，那么，this对象指向window，并且，不会默认返回任何对象（除非显性声明返回值）。

还是拿Person函数为例，直接调用Person函数：

var person1 = Person('nicole');
person1; // undefined
window.name; // nicole

可见，直接调用构造函数的结果，并不是我们想要的。

3）小结

为了防止因为忘记使用new关键字而调用构造函数，可以加一些判断条件强行调用new关键字，代码如下：

function Person(name){
  if (!(this instanceof Person)) {
    return new Person(name);
  }
  this.name = name;
  this.say = function(){
    return "I am " + this.name;
  }
}

var person1 = Person('nicole');
console.log(person1.say()); // I am nicole
var person2 = new Person('lisa');
console.log(person2.say()); // I am lisa

【相关推荐：javascript学习教程】

Das obige ist der detaillierte Inhalt vonWas ist ein Konstruktor? Detaillierte Erklärung der Konstruktoren in JavaScript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!