Das Implementierungsprinzip und die Umschreibemethode von NEW in JS

Der neue Operator in JavaScript erstellt eine Instanz eines benutzerdefinierten Objekttyps oder eine Instanz eines integrierten Objekts mit einem Konstruktor. In diesem Artikel werden Ihnen das Implementierungsprinzip und die Umschreibemethode von NEW vorgestellt.

Wenn es um Neu geht, wird es definitiv mit Klassen und Instanzen verknüpft, wie zum Beispiel:

function Func() {
    let x = 100;    
    this.num = x +}
let f = new Func();

Im obigen Code erstellen wir zunächst eine Funktion, wenn objektorientiert eine Instanz der Function-Klasse erstellt wird. Wenn die Funktion direkt ausgeführt wird, handelt es sich um eine gewöhnliche Funktion. Wenn sie mit new ausgeführt wird, wird die Funktion als benutzerdefinierte Klasse bezeichnet.

Wenn es sich um eine normale Funktionsausführung handelt, werden mehrere Dinge wie folgt ausgeführt:

• Bilden Sie einen neuen Ausführungskontext EC (Execution Context Execution Environment)

• Bilden Sie ein AO-Variablenobjekt (Activation Object), initialisieren Sie Argumente und formale Parameterzuweisungen
  

• Initialisieren Sie die Bereichskette
  

• Codeausführung
  

Wenn die neue Funktion ausgeführt wird, hat sie sowohl die normale Funktionsausführungsseite als auch ihre eigenen einzigartigen Dinge:

• Erstellen Sie standardmäßig ein Objekt, und dieses Objekt ist eine Instanz der aktuellen Klasse

• Deklarieren Sie seinen Zeiger und lassen Sie ihn auf diese neu erstellte Instanz zeigen
  

• Egal ob return oder nicht, die neu erstellte Instanz wird zurückgegeben. Hier gibt es einen besonderen Punkt, wenn der Benutzer den Inhalt selbst zurückgibt ein Referenztypwert, dann wird die standardmäßig zurückgegebene Instanz überschrieben und der zurückgegebene Wert ist keine Instanz der Klasse mehr
  

console.log(f);  //=>{num:200}
//f是Func这个类的实例 
//相当于给创建的实例对象新增一个num的属性 obj.num=200 （因为具备普通函数执行的一面，所以只有this.xxx=xxx才和创建的实例有关系，此案例中的x只是AO中的私有变量）

console.log(f instanceof Func); //=>TRUE instanceof用来检测某一个实例是否属于这个类

Jedes Mal, wenn etwas Neues herauskommt, wird es ist eine neue Instanz. Objekt

console.log(f === f2); //=>false

Jetzt, da wir wissen, was new getan hat, versuchen wir es noch einmal neu:

/* 
 * 内置NEW的实现原理 
 * @params
 *    Func：操作的那个类
 *    ARGS：NEW类的时候传递的实参集合
 * @return
 *    实例或者自己返回的对象
 */
function _new(Func, ...args) {
    //默认创建一个实例对象（而且是属于当前这个类的一个实例）
    let obj = {};

    //也会把类当做普通函数执行
    //执行的时候要保证函数中的this指向创建的实例
    let result = Func.call(obj, ...args);

    //若客户自己返回引用值，则以自己返回的为主，否则返回创建的实例
    if ((result !== null && typeof result === "object") || (typeof result === "function")) {
        return result;
    }
    return obj;
}

Lass es uns versuchen:

let f3 = _new(Func);
console.log(f3); // =>{num: 200}

Lass uns mit dem Testen fortfahren:

Func.prototype.log = function () {
    console.log('ok');
}

let f4 = _new(Func);
f4.log(); //=>Uncaught TypeError: f4.log is not a function

Mit anderen Worten, die Methode auf dem Func-Prototyp kann nicht auf seiner Instanz aufgerufen werden. Wir müssen sie noch ändern:

/* 
 * 内置NEW的实现原理 
 * @params
 *    Func：操作的那个类
 *    ARGS：NEW类的时候传递的实参集合
 * @return
 *    实例或者自己返回的对象
 */
function _new(Func, ...args) {
    //默认创建一个实例对象（而且是属于当前这个类的一个实例）
    // let obj = {};
    let obj = Object.create(Func.prototype);

    //也会把类当做普通函数执行
    //执行的时候要保证函数中的this指向创建的实例
    let result = Func.call(obj, ...args);

    //若客户自己返回引用值，则以自己返回的为主，否则返回创建的实例
    if ((result !== null && typeof result === "object") || (typeof result === "function")) {
        return result;
    }
    return obj;
}

Das sollte ausreichen.

let f6 = _new(Func);
f6.log(); //=>ok

Dieser Artikel stammt aus der Rubrik JS-Tutorial, willkommen zum Lernen!

Das obige ist der detaillierte Inhalt vonDas Implementierungsprinzip und die Umschreibemethode von NEW in JS. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!