Condivisione della tecnologia

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

funzione

Ogni funzione è un'istanza del tipo Function e Function dispone anche di proprietà e metodi, proprio come gli altri tipi di riferimento. Le funzioni sono oggetti e il nome della funzione è un puntatore all'oggetto funzione e non è necessariamente strettamente legato alla funzione stessa.

Definizione dichiarativa di funzione della definizione di funzione

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

Espressione di funzione della definizione di funzione

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

funzione freccia di definizione della funzione

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

costruttore di definizioni di funzione

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

funzione freccia

Le funzioni freccia possono essere utilizzate ovunque sia possibile utilizzare un'espressione di funzione.

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;
 

Sebbene le funzioni freccia abbiano una sintassi semplice, esistono molte situazioni in cui non sono adatte. Le funzioni freccia non possono utilizzare argomenti, super, new.target, né possono essere utilizzate come costruttori. Inoltre, le funzioni freccia non hanno un attributo prototipo.

Parametri nelle funzioni freccia

La funzione è definita utilizzando la sintassi della freccia, quindi non è possibile accedere ai parametri passati alla funzione utilizzando la parola chiave topics, ma è possibile accedervi solo tramite i parametri denominati definiti.

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

Nome della funzione

Una funzione può avere più nomi.

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

Valore del parametro predefinito

È possibile assegnare un valore predefinito a un parametro utilizzando = dopo il parametro nella definizione della funzione.

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

I valori predefiniti dei parametri non si limitano ai valori primitivi o ai tipi di oggetto, è possibile utilizzare anche i valori restituiti dalla funzione chiamante

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'

Espansione e raccolta di parametri

ES6 aggiunge un nuovo operatore di estensione, che può essere utilizzato per gestire e combinare i dati di raccolta in modo molto conciso. Lo scenario più utile per l'operatore spread è l'elenco dei parametri in una definizione di funzione, dove può sfruttare appieno la tipizzazione debole e i parametri di lunghezza variabile del linguaggio. L'operatore di spread può essere utilizzato per passare parametri quando si chiama una funzione o per definire parametri di funzione.

Parametri estesi

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));

Raccogli i parametri

Se sono presenti parametri denominati davanti ai parametri raccolti, verranno raccolti solo i parametri rimanenti, in caso contrario verrà ottenuto un array vuoto; Poiché il risultato della raccolta dei parametri è variabile, può essere utilizzato solo come ultimo parametro.

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

Dichiarazione di funzione ed espressione di funzione

Prima che venga eseguito qualsiasi codice, il motore JavaScript legge la dichiarazione della funzione e genera la definizione della funzione nel contesto di esecuzione. L'espressione della funzione deve attendere fino all'esecuzione del codice fino alla riga prima che la definizione della funzione venga generata nel contesto di esecuzione.

// 没问题 
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; 
};