Extensions des paramètres de fonction

Paramètres par défaut

Utilisation de base

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

Remarque : Lors de l'utilisation de paramètres par défaut de fonction, les noms de paramètres en double ne sont pas autorisés.

//Aucune erreur function fn(name,name){ console.log(name); } //Erreur //SyntaxError : nom de paramètre dupliqué non autorisé dans ce contexte function fn(name,name,age=17){ console.log(name+","+age); }

Les paramètres par défaut ne sont utilisés que lorsqu'aucun argument n'est passé, ou lorsque l'argument est undefined. La valeur null est considérée comme une valeur valide transmise.

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

Les valeurs par défaut des paramètres de fonction ont une zone morte temporelle. Dans une expression de valeur par défaut de paramètre de fonction, une valeur de paramètre qui n'a pas encore été initialisée ne peut pas être utilisée comme valeur par défaut pour d'autres paramètres.

function f(x,y=x){ console.log(x,y); } f(1); // 1 1 function f(x=y){ console.log(x); } f(); // ReferenceError : y n'est pas défini

Paramètres du reste

Les paramètres du reste sont utilisés pour représenter un nombre indéfini de paramètres, sous la forme ...variableName, composée de ... plus un identifiant de paramètre nommé. Le paramètre nommé ne peut être placé qu'à la fin de la liste des paramètres, et il ne peut y avoir qu'un seul paramètre du reste.

Utilisation de base

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

Fonctions fléchées

Les fonctions fléchées offrent une manière plus concise d'écrire des fonctions. La syntaxe de base est :

Parameter => function body

Utilisation de base :

var f = v => v; //Équivalent à var f = function(a){ return a; } f(1); //1

Lorsqu'une fonction fléchée n'a aucun paramètre ou a plusieurs paramètres, utilisez()des parenthèses pour les entourer.

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

Lorsque le corps d'une fonction fléchée contient plusieurs instructions, utilisez{}des accolades pour l'encapsuler, ce qui représente un bloc de code. Lorsqu'il n'y a qu'une seule instruction et qu'un résultat doit être renvoyé, vous pouvez omettre{}, et le résultat sera renvoyé automatiquement.

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

Lorsqu'une fonction fléchée doit renvoyer un objet, afin de le distinguer d'un bloc de code, utilisez()des parenthèses pour entourer l'objet.

//Erreur var f = (id,name) => {id: id, name: name}; f(6,2); // SyntaxError: Unexpected token : //Aucune erreur var f = (id,name) => ({id: id, name: name}); f(6,2); // {id: 6, name: 2}

Remarque : il n'y a pas de liaisons pour this, super, arguments et new.target.

var func = () => { //Il n'y a pas d'objet this à l'intérieur d'une fonction fléchée. //Le this à ce stade est l'objet this extérieur, à savoir Window. console.log(this) } func(55) // Window var func = () => { console.log(arguments) } func(55); // ReferenceError : arguments n'est pas défini

L'objet this dans le corps de la fonction fléchée est l'objet au moment où la fonction est définie, et non l'objet au moment où la fonction est utilisée.

function fn(){ setTimeout(()=>{ //Lors de la définition, this est lié à l'objet this à l'intérieur de fn. console.log(this.a); },0) } var a = 20; //L'objet this de fn est {a: 18} fn.call({a: 18}); // 18

Il ne peut pas être utilisé comme constructeur, ce qui signifie que vous ne pouvez pas utiliser la commande new, sinon une erreur sera levée.

Cas d'utilisation appropriés

Avant ES6, l'objet this en JavaScript était toujours un casse-tête. Dans les fonctions de rappel, on voyait souvent du code comme var self = this, afin de transmettre le this externe dans la fonction de rappel. Avec les fonctions fléchées, ce n'est plus nécessaire ; vous pouvez simplement utiliser this directement.

//Fonctions de rappel 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

Par conséquent, lorsque nous devons maintenir un contexte this, nous pouvons utiliser des fonctions fléchées.

Cas d’utilisation inappropriés

Définition d’une méthode de fonction, et la méthode contient this

var Person = { 'age': 18, 'sayHello': ()=>{ console.log(this.age); } }; var age = 20; Person.sayHello(); // 20 //À ce stade, this pointe vers l’objet global. var Person1 = { 'age': 18, 'sayHello': function () { console.log(this.age); } }; var age = 20; Person1.sayHello(); // 18 //À ce stade, this pointe vers l’objet Person1.

Lorsque this dynamique est nécessaire

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

La fonction écouteur de button est une fonction flèche, donc le this à l'intérieur de la fonction écouteur pointe vers l'objet this externe au moment de la définition, à savoir Window, ce qui empêche d'opérer sur l'objet button cliqué.