Zusammenfassung von Beispielen für Funktionsaufrufmuster in grundlegenden Javascript-Tutorials

Die Funktion wird nur ausgeführt, wenn sie aufgerufen wird. Der Aufrufoperator ist ein Klammerpaar, das auf einen beliebigen Ausdruck folgt, der einen Funktionswert erzeugt. Die Klammern können null oder mehr durch Kommas getrennte Ausdrücke enthalten. Jeder Ausdruck erzeugt einen Parameterwert und jedem Parameterwert wird der formale Parametername

zugewiesen, der bei der Deklaration der Funktion definiert wurde. JavaScript verfügt über insgesamt 4 Aufrufmodi: Funktionsaufrufmodus, Methodenaufrufmodus, Konstruktoraufrufmodus und indirekter Aufrufmodus

【1】Funktionsaufrufmodus

Wenn eine Funktion keine Eigenschaft eines Objekts ist, wird sie als Funktion aufgerufen. Bei gewöhnlichen Funktionsaufrufen ist der Rückgabewert der Funktion der Wert des aufrufenden Ausdrucks

function add(x,y){    
   return x+y;
}
var sum = add(3,4);
console.log(sum)//7

Beim Aufruf einer Funktion im Funktionsaufrufmodus ist diese im nicht-strikten Modus an das globale Objekt gebunden ; im strikten Modus ist dies undefiniert

function add(x,y){
    console.log(this);//window}    
add();

function add(x,y){    
'use strict';
    console.log(this);//undefined
}    
add();//window

Daher kann „this“ verwendet werden, um zu bestimmen, ob der aktuelle Modus strikt ist

var strict = (function(){return !this;}());

umschreiben

weil Dies in der Funktion im Funktionsaufrufmodus an das globale Objekt gebunden ist, sodass globale Eigenschaften überschrieben werden

var a = 0;
function fn(){
    this.a = 1;
}
fn();
console.log(this,this.a,a);//window 1 1

【2】Methodenaufrufmodus

Wenn eine Funktion wird gespeichert. Wenn es sich um eine Eigenschaft eines Objekts handelt, nennen wir es eine Methode. Beim Aufruf einer Methode wird diese an das Objekt gebunden. Wenn der aufrufende Ausdruck eine Aktion zum Extrahieren von Attributen enthält, wird er als Methode aufgerufen.

var o = {
    m: function(){
        console.log(1);
    }
};
o.m();//1

Die Methode kann damit auf das Objekt zugreifen, zu dem sie gehört, und so den Wert vom Objekt abrufen oder das Objekt ändern. Die Bindung dieser an das Objekt erfolgt zum Zeitpunkt des Aufrufs. Methoden, die auf diese Weise den Kontext der Objekte erhalten können, zu denen sie gehören, werden öffentliche Methoden genannt

var o = {
    a: 1,
    m: function(){
        return this;
    },
    n: function(){
        this.a = 2;
    }
};
console.log(o.m().a);//1
o.n();
console.log(o.m().a);//2

Jede Funktion, die als Methode aufgerufen wird, übergibt tatsächlich einen impliziten tatsächlichen Parameter – dieser tatsächliche Parameter ist ein Objekt , Das übergeordnete Element des Methodenaufrufs ist dieses Objekt. Im Allgemeinen können Methoden, die auf diesem Objekt basieren, verschiedene Operationen ausführen. Die Syntax des Methodenaufrufs hat deutlich gezeigt, dass die Funktion auf einem Objekt basiert

rect.setSize(width,height);
setRectSize(rect,width,height);

Annahme Die beiden oben genannten Codezeilen haben genau die gleiche Funktion. Sie arbeiten beide mit einem hypothetischen Objekt rect. Wie Sie sehen können, zeigt die Methodenaufrufsyntax in der ersten Zeile deutlich an, dass der Träger dieser Funktionsausführung das Rect-Objekt ist und alle Operationen in der Funktion auf diesem Objekt basieren

Im Gegensatz zu Variablen ist das Schlüsselwort Dies hat keinen Gültigkeitsbereich. Aufgrund der Einschränkung erbt eine verschachtelte Funktion dies nicht von der Funktion, die sie aufruft. Wenn eine verschachtelte Funktion als Methode aufgerufen wird, zeigt ihr Wert auf das Objekt, das sie aufgerufen hat. Wenn die verschachtelte Funktion als Funktion aufgerufen wird, ist dieser Wert entweder ein globales Objekt (im nicht-strikten Modus) oder undefiniert (im strikten Modus)

var o = {
    m: function(){
         function n(){
             return this;
         }
         return n();
    }
}
console.log(o.m());//window

var o = {
    m: function(){
         function n(){
             'use strict';
             return this;
         }
         return n();
    }
}
console.log(o.m());//undefined

Wenn Sie auf die zugreifen möchten Wenn Sie diesen Wert dieser externen Funktion verwenden möchten, müssen Sie den Wert dieser Variable in einer Variablen speichern. Diese Variable und die interne Funktion befinden sich beide im selben Bereich. Normalerweise wird die Variable self oder that verwendet, um dies zu speichern

var o = {
    m: function(){
        var self = this;
        console.log(this === o);//true
         function n(){
             console.log(this === o);//false
             console.log(self === o);//true
             return self;
         }
         return n();
    }
}
console.log(o.m() === o);//true

【3】Konstruktoraufrufmodus

Wenn einem Funktions- oder Methodenaufruf das Schlüsselwort new vorangestellt ist, handelt es sich um einen Konstruktoraufruf

function fn(){    
   this.a = 1;
};
var obj = new fn();
console.log(obj.a);//1

Wenn der Konstruktoraufruf eine Reihe von Argumentlisten in Klammern enthält, werden diese Argumentausdrücke zuerst ausgewertet und dann an die Funktion übergeben

function fn(x){    
  this.a = x;
};
var obj = new fn(2);
console.log(obj.a);//2

Wenn der Konstruktor keine Formularparameter hat , erlaubt die Syntax des JavaScript-Konstruktoraufrufs das Weglassen der tatsächlichen Parameterliste und Klammern. Bei jedem Konstruktoraufruf ohne formale Parameter können die Klammern weggelassen werden

var o = new Object();//等价于
var o = new Object;

[Hinweis] Obwohl der Konstruktor wie ein Methodenaufruf aussieht, verwendet er dennoch das neue Objekt als aufrufenden Kontext. Das heißt, im Ausdruck new o.m() ist der Aufrufkontext nicht o

var o = {
    m: function(){
        return this;
    }
}
var obj = new o.m();
console.log(obj,obj === o);//{} false
console.log(obj.constructor === o.m);//true

Konstruktoren verwenden normalerweise nicht das Schlüsselwort return. Sie initialisieren normalerweise neue Objekte im Funktionskörper des Konstruktors ausgeführt wird, wird es explizit zurückgegeben. In diesem Fall ergibt der Konstruktoraufrufausdruck den Wert dieses neuen Objekts

function fn(){    
  this.a = 2;
}var test = new fn();
console.log(test);//{a:2}

Wenn der Konstruktor eine Rückgabeanweisung verwendet, aber keinen Rückgabewert angibt oder einen primitiven Wert zurückgibt, dann Der Rückgabewert wird ignoriert und dieses neue Objekt wird als Aufrufergebnis verwendet

function fn(){
    this.a = 2;
    return;
}
var test = new fn();
console.log(test);//{a:2}

Wenn der Konstruktor explizit die Return-Anweisung verwendet, um ein Objekt zurückzugeben, dann ist der Wert des aufrufenden Ausdrucks dieses Objekt

var obj = {a:1};
function fn(){
    this.a = 2;
    return obj;
}
var test = new fn();
console.log(test);//{a:1}

【4】Indirekter Aufrufmodus

Funktionen in JavaScript sind ebenfalls Objekte, und Funktionsobjekte können auch Methoden enthalten. Mit den Methoden call() und apply() können Funktionen indirekt aufgerufen werden

Beide Methoden ermöglichen die explizite Angabe des für den Aufruf erforderlichen Wertes, d. h. jede Funktion kann als Methode einer beliebigen Funktion verwendet werden Wird aufgerufen, auch wenn diese Funktion keine Methode dieses Objekts ist. Beide Methoden können die tatsächlichen Parameter des Aufrufs angeben. Die Methode call() verwendet ihre eigene Liste tatsächlicher Parameter als tatsächliche Parameter der Funktion, und die Methode apply() erfordert die Übergabe der Parameter in Form eines Arrays

var obj = {};
function sum(x,y){
    return x+y;
}
console.log(sum.call(obj,1,2));//3
console.log(sum.apply(obj,[1,2]));//3

Das obige ist der detaillierte Inhalt vonZusammenfassung von Beispielen für Funktionsaufrufmuster in grundlegenden Javascript-Tutorials. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!