Partage de technologie

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

fonction

Chaque fonction est une instance du type Function et Function possède également des propriétés et des méthodes, tout comme les autres types de référence. Les fonctions sont des objets et le nom de la fonction est un pointeur vers l'objet fonction et n'est pas nécessairement étroitement lié à la fonction elle-même.

Définition déclarative de fonction de la définition de fonction

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

Expression de fonction de la définition de fonction

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

fonction de flèche de définition de fonction

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

constructeur de définition de fonction

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

fonction flèche

Les fonctions fléchées peuvent être utilisées partout où une expression de fonction peut être utilisée.

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;
 

Bien que les fonctions fléchées aient une syntaxe simple, il existe de nombreuses situations dans lesquelles elles ne conviennent pas. Les fonctions fléchées ne peuvent pas utiliser d'arguments, super, new.target, ni être utilisées comme constructeurs. De plus, les fonctions fléchées n'ont pas d'attribut prototype.

Paramètres dans les fonctions fléchées

La fonction est définie à l'aide de la syntaxe des flèches, de sorte que les paramètres transmis à la fonction ne sont pas accessibles à l'aide du mot-clé arguments, mais ne sont accessibles que via les paramètres nommés définis.

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

Nom de la fonction

Une fonction peut avoir plusieurs noms.

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

Valeur du paramètre par défaut

Vous pouvez attribuer une valeur par défaut à un paramètre en utilisant = après le paramètre dans la définition de la fonction.

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

Les valeurs des paramètres par défaut ne se limitent pas aux valeurs primitives ou aux types d'objets, les valeurs renvoyées par la fonction appelante peuvent également être utilisées

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'

Expansion et collecte de paramètres

ES6 ajoute un nouvel opérateur d'extension, qui peut être utilisé pour exploiter et combiner les données de collecte de manière très concise. Le scénario le plus utile pour l'opérateur de spread est la liste de paramètres dans une définition de fonction, où il peut tirer pleinement parti des paramètres de typage faible et de longueur variable du langage. L'opérateur spread peut être utilisé pour transmettre des paramètres lors de l'appel d'une fonction ou pour définir des paramètres de fonction.

Paramètres étendus

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

Collecter les paramètres

S'il y a des paramètres nommés devant les paramètres collectés, seuls les paramètres restants seront collectés ; sinon, un tableau vide sera obtenu ; Le résultat de la collecte des paramètres étant variable, il ne peut être utilisé que comme dernier paramètre.

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

Déclaration de fonction et expression de fonction

Avant qu'un code ne soit exécuté, le moteur JavaScript lit la déclaration de fonction et génère la définition de fonction dans le contexte d'exécution. L'expression de fonction doit attendre que le code soit exécuté sur sa ligne avant que la définition de fonction ne soit générée dans le contexte d'exécution.

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