Funktionsparameter-Erweiterungen

Standardparameter

Grundlegende Verwendung

function fn(name,age=17){ console.log(name+","+age); } fn("Amy",18); // Amy,18 fn("Amy",""); // Amy, fn("Amy"); // Amy,17

Hinweis: Bei Verwendung von Standardparametern für Funktionen sind doppelte Parameternamen nicht erlaubt.

//Kein Fehler function fn(name,name){ console.log(name); } //Fehler //SyntaxError: Doppelter Parametername in diesem Kontext nicht zulässig function fn(name,name,age=17){ console.log(name+","+age); }

Standardparameter werden nur verwendet, wenn kein Argument übergeben wird oder wenn das Argument undefined ist. Der Wert null wird als gültiger übergebener Wert betrachtet.

function fn(name,age=17){ console.log(name+","+age); } fn("Amy",null); // Amy,null

Standardwerte für Funktionsparameter haben eine temporale Dead Zone. In einem Standardwertausdruck für Funktionsparameter kann ein Parameterwert, der noch nicht initialisiert wurde, nicht als Standardwert für andere Parameter verwendet werden.

function f(x,y=x){ console.log(x,y); } f(1); // 1 1 function f(x=y){ console.log(x); } f(); // ReferenceError: y ist nicht definiert

Rest-Parameter

Rest-Parameter werden verwendet, um eine unbestimmte Anzahl von Parametern darzustellen, in der Form ...variableName, bestehend aus ... plus einem benannten Parameterbezeichner. Der benannte Parameter kann nur am Ende der Parameterliste stehen, und es kann nur einen Rest-Parameter geben.

Grundlegende Verwendung

function f(...values){ console.log(values.length); } f(1,2); //2 f(1,2,3,4); //4

Pfeilfunktionen

Arrow-Funktionen bieten eine prägnantere Möglichkeit, Funktionen zu schreiben. Die grundlegende Syntax lautet:

Parameter => function body

Grundlegende Verwendung:

var f = v => v; //Entspricht var f = function(a){ return a; } f(1); //1

Wenn die Arrow-Funktion keine Parameter oder mehrere Parameter hat, verwende()runde Klammern, um sie einzuschließen.

var f = (a,b) => a+b; f(6,2); //8

Wenn der Rumpf der Arrow-Funktion mehrere Anweisungen enthält, verwende{}geschweifte Klammern, um ihn zu umschließen, was einen Codeblock darstellt. Wenn es nur eine Anweisung gibt und ein Ergebnis zurückgegeben werden muss, kannst du weglassen{}, und das Ergebnis wird automatisch zurückgegeben.

var f = (a,b) => { let result = a+b; return result; } f(6,2); // 8

Wenn eine Arrow-Funktion ein Objekt zurückgeben muss, verwende()runde Klammern, um das Objekt zu umschließen, um es von einem Codeblock zu unterscheiden.

//Fehler var f = (id,name) => {id: id, name: name}; f(6,2); // SyntaxError: Unexpected token : //Kein Fehler var f = (id,name) => ({id: id, name: name}); f(6,2); // {id: 6, name: 2}

Hinweis: Es gibt keine Bindungen für this, super, arguments und new.target.

var func = () => { //Es gibt kein this-Objekt innerhalb einer Arrow-Funktion. //Das this an dieser Stelle ist das äußere this-Objekt, nämlich Window. console.log(this) } func(55) // Window var func = () => { console.log(arguments) } func(55); // ReferenceError: arguments ist nicht definiert

Das this-Objekt im Rumpf einer Arrow-Funktion ist das Objekt zum Zeitpunkt der Definition der Funktion, nicht das Objekt zum Zeitpunkt der Verwendung der Funktion.

function fn(){ setTimeout(()=>{ //Bei der Definition wird this an das this-Objekt innerhalb von fn gebunden. console.log(this.a); },0) } var a = 20; //Das this-Objekt von fn ist {a: 18} fn.call({a: 18}); // 18

Es kann nicht als Konstruktor verwendet werden, was bedeutet, dass Sie den new-Befehl nicht verwenden können, andernfalls wird ein Fehler ausgelöst.

Geeignete Anwendungsfälle

Vor ES6 war das this-Objekt in JavaScript immer ein Kopfschmerz. In Callback-Funktionen sah man oft Code wie var self = this, um das externe this an die Callback-Funktion zu übergeben. Mit Arrow-Funktionen ist das nicht mehr nötig; Sie können this einfach direkt verwenden.

//Callback-Funktionen var Person = { 'age': 18, 'sayHello': function () { setTimeout(function () { console.log(this.age); }); } }; var age = 20; Person.sayHello(); // 20 var Person1 = { 'age': 18, 'sayHello': function () { setTimeout(()=>{ console.log(this.age); }); } }; var age = 20; Person1.sayHello(); // 18

Daher können wir, wenn wir einen this-Kontext beibehalten müssen, Arrow-Funktionen verwenden.

Ungeeignete Anwendungsfälle

Definieren einer Funktionsmethode, und die Methode enthält this

var Person = { 'age': 18, 'sayHello': ()=>{ console.log(this.age); } }; var age = 20; Person.sayHello(); // 20 //An diesem Punkt zeigt this auf das globale Objekt. var Person1 = { 'age': 18, 'sayHello': function () { console.log(this.age); } }; var age = 20; Person1.sayHello(); // 18 //An diesem Punkt zeigt this auf das Person1-Objekt.

Wenn dynamisches this benötigt wird

var button = document.getElementById('userClick'); button.addEventListener('click', () => { this.classList.toggle('on'); });

Die Listener-Funktion von button ist eine Arrow-Funktion, daher zeigt das this innerhalb der Listener-Funktion auf das äußere this-Objekt zum Zeitpunkt der Definition, nämlich Window, was dazu führt, dass das angeklickte button-Objekt nicht bedient werden kann.