Technologieaustausch

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Funktion

Jede Funktion ist eine Instanz des Funktionstyps, und die Funktion verfügt wie andere Referenztypen auch über Eigenschaften und Methoden. Funktionen sind Objekte, und der Funktionsname ist ein Zeiger auf das Funktionsobjekt und nicht unbedingt eng an die Funktion selbst gebunden.

Funktionsdeklarative Definition der Funktionsdefinition

function sum (n1,n2){
return n1+n2;
}

Funktionsausdruck der Funktionsdefinition

let sum = function(n1,n2){
return n1+n2;
};

Funktionsdefinition Pfeilfunktion

let sum = (n1,n2)=>{
return n1+n2;
};

Funktionsdefinitionskonstruktor

let sum = new Function("n1","n2","return n1+n2");
/*这个构造函数接收任意多个字符串参数，
最后一个参数始终会被当成函数体，
而之前的参数都是新函数的参数*/

Pfeilfunktion

Pfeilfunktionen können überall dort verwendet werden, wo ein Funktionsausdruck verwendet werden kann.

let sum = (a,b)=>{
return a+b;
};
let sum1 = function(a,b){
return a+b;
};
//箭头函数适合嵌入函数的场景
let arr = [1,2,3];
console.log(arr.map(function(i) {return i+1;}));
console.log(arr.map((i)=>{return i+1;}));
//二者结果一样，但是箭头函数更为简洁
 
//如果只有一个参数，括号可以不用。只有没有参数，或者多个参数的情况下，才使用括号
 
let double = (x)=>{return 2*x;};
let triple = x => {return 3*x};
 
//箭头函数也可以不使用大括号，但这样会改变函数的行为。使用大括号就说明包含函数体，可以在一
//个函数中包含多条语句，跟常规函数一样。如果不使用，后面只能有一行代码。
 
let double = (x)=>{return 2*x;};
let triple = x=>3*x;
 

Obwohl Pfeilfunktionen eine einfache Syntax haben, gibt es viele Situationen, in denen sie nicht geeignet sind. Pfeilfunktionen können weder die Argumente super noch new.target verwenden und auch nicht als Konstruktoren verwendet werden. Darüber hinaus verfügen Pfeilfunktionen nicht über ein Prototypattribut.

Parameter in Pfeilfunktionen

Die Funktion wird mithilfe der Pfeilsyntax definiert, sodass auf die an die Funktion übergebenen Parameter nicht mit dem Schlüsselwort arguments, sondern nur über die definierten benannten Parameter zugegriffen werden kann.

function foo() { 
 console.log(arguments[0]); 
} 
foo(5); // 5 
let bar = () => { 
 console.log(arguments[0]); 
}; 
bar(5); // ReferenceError: arguments is not defined

Funktionsname

Eine Funktion kann mehrere Namen haben.

function sum(num1, num2) { 
 return num1 + num2; 
} 
console.log(sum(10, 10)); // 20 
let anotherSum = sum; 
console.log(anotherSum(10, 10)); // 20 
sum = null; 
console.log(anotherSum(10, 10)); // 20

Standardparameterwert

Sie können einem Parameter einen Standardwert zuweisen, indem Sie = nach dem Parameter in der Funktionsdefinition verwenden.

function makeKing(name = 'Henry') { 
 return `King ${name} VIII`; 
} 
console.log(makeKing('Louis')); // 'King Louis VIII' 
console.log(makeKing()); // 'King Henry VIII'

Standardparameterwerte sind nicht auf Grundwerte oder Objekttypen beschränkt, es können auch von der aufrufenden Funktion zurückgegebene Werte verwendet werden

let romanNumerals = ['I', 'II', 'III', 'IV', 'V', 'VI']; 
let ordinality = 0; 
function getNumerals() { 
 // 每次调用后递增
 return romanNumerals[ordinality++]; 
} 
function makeKing(name = 'Henry', numerals = getNumerals()) { 
 return `King ${name} ${numerals}`; 
} 
console.log(makeKing()); // 'King Henry I'
console.log(makeKing('Louis', 'XVI')); // 'King Louis XVI' 
console.log(makeKing()); // 'King Henry II' 
console.log(makeKing()); // 'King Henry III'

Parametererweiterung und -sammlung

ES6 fügt einen neuen Erweiterungsoperator hinzu, mit dem Sammlungsdaten sehr präzise bedient und kombiniert werden können. Das nützlichste Szenario für den Spread-Operator ist die Parameterliste in einer Funktionsdefinition, wo er die schwache Typisierung und die Parameter variabler Länge der Sprache voll ausnutzen kann. Der Spread-Operator kann zum Übergeben von Parametern beim Aufruf einer Funktion oder zum Definieren von Funktionsparametern verwendet werden.

Erweiterte Parameter

let values = [1, 2, 3, 4]; 
function getSum() { 
 let sum = 0; 
 for (let i = 0; i < arguments.length; ++i) { 
 sum += arguments[i]; 
 } 
 return sum; 
} 
//不使用扩展操作符实现累加
console.log(getSum.apply(null,values));
 
//使用扩展操作符
console.log(getSum(...values));

Parameter sammeln

Wenn vor den erfassten Parametern benannte Parameter stehen, werden nur die übrigen Parameter erfasst; andernfalls wird ein leeres Array erhalten. Da das Ergebnis der Parametererfassung variabel ist, kann es nur als letzter Parameter verwendet werden.

 
function getProduct(...values,lastValue){}//不可以
function ignoreFirst(firstValue,...values){console.log(values)}//可以
ignoreFirst(); // [] 
ignoreFirst(1); // [] 
ignoreFirst(1,2); // [2] 
ignoreFirst(1,2,3); // [2, 3]

Funktionsdeklaration und Funktionsausdruck

Bevor Code ausgeführt wird, liest die JavaScript-Engine die Funktionsdeklaration und generiert die Funktionsdefinition im Ausführungskontext. Der Funktionsausdruck muss warten, bis der Code in seiner Zeile ausgeführt wird, bevor die Funktionsdefinition im Ausführungskontext generiert wird.

// 没问题 
console.log(sum(10, 10)); 
function sum(num1, num2) { 
 return num1 + num2; 
}
/*函数声明提升*/
 
 
// 会出错
console.log(sum(10, 10)); 
let sum = function(num1, num2) { 
 return num1 + num2; 
};