web-dev-qa-db-fra.com

Utilisation de la variable _ (trait de soulignement) avec les fonctions de flèche dans ES6 / Typescript

Je suis tombé sur cette construction dans un exemple Angular et je me demande pourquoi cette option est choisie:

_ => console.log('Not using any parameters');

Je comprends que la variable _ signifie ne s’en soucie pas/qu’elle n’est pas utilisée, mais comme c’est la seule variable, y at-il lieu de préférer l’utilisation de _ par-dessus:

() => console.log('Not using any parameters');

Cela ne peut sûrement pas contenir environ un caractère de moins à taper. La syntaxe () traduit mieux l'intention à mon avis et est également plus spécifique au type car sinon je pense que le premier exemple aurait dû ressembler à ceci:

(_: any) => console.log('Not using any parameters');

Au cas où cela serait important, c'était dans ce contexte qu'il a été utilisé:

submit(query: string): void {
    this.router.navigate(['search'], { queryParams: { query: query } })
      .then(_ => this.search());
}
javascripttypescriptecmascript-6arrow-functions
93
Halt

La raison pour laquelle ce style peut être utilisé (et peut-être pourquoi il a été utilisé ici) est que _ est un caractère plus court que ().

Les parenthèses facultatives relèvent du même problème de style que accolades facultatives . C'est une question de goût et de style de code pour la plupart, mais la verbosité est favorisée ici en raison de la cohérence.

Alors que les fonctions de flèche permettent un paramètre unique sans parenthèses, il est incohérent avec les paramètres zéro, unique déstructuré, unique et plusieurs:

let zeroParamFn = () => { ... };
let oneParamFn = param1 => { ... };
let oneParamDestructuredArrFn = ([param1]) => { ... };
let oneParamDestructuredObjFn = ({ param1 }) => { ... };
let twoParamsFn = (param1, param2) => { ... };
let restParamsFn = (...params) => { ... };

Bien que is declared but never used error a été corrigé dans TypeScript 2. pour les paramètres soulignés, _ peut également déclencher unused variable/parameter warning à partir d'un linter ou d'un IDE. C'est un argument considérable contre le faire.

_ peut être utilisé de manière conventionnelle pour les paramètres ignorés (comme l’a déjà expliqué l’autre réponse). Bien que cela puisse être considéré comme acceptable, cette habitude peut entraîner un conflit avec l'espace de noms _ Underscore/Lodash, mais semble également déroutante lorsqu'il existe plusieurs paramètres ignorés. Pour cette raison, il est avantageux d’avoir correctement nommé des paramètres soulignés (pris en charge dans TS 2.0), d’économiser du temps lors de la détermination de la signature de la fonction et de la raison pour laquelle les paramètres sont marqués comme ignorés (cela défie l’objet du paramètre _ en tant que raccourci ):

let fn = (param1, _unusedParam2, param3) => { ... };

Pour les raisons énumérées ci-dessus, j'estime personnellement que le style de code _ => { ... } est un mauvais ton qu'il convient d'éviter.

74
Estus Flask

La syntaxe () traduit mieux l’intention et est plus spécifique au type

Pas exactement. () indique que la fonction n'attend aucun argument, elle ne déclare aucun paramètre. La fonction .length est 0.

Si vous utilisez _, il est explicitement indiqué que la fonction recevra un argument, mais que vous ne vous en souciez pas. La fonction .length sera 1, ce qui peut avoir de l'importance dans certains cadres.

Donc, d’un point de vue typographique, cela pourrait être plus précis (surtout si vous ne le tapez pas avec any mais, par exemple, _: Event). Et comme vous l'avez dit, il faut un caractère de moins à taper, ce qui est également plus facile à atteindre sur certains claviers.

56
Bergi

J'imagine que _ => est simplement utilisé sur () => parce que _ est commun dans d'autres langues où il n'est pas permis d'omettre des paramètres comme dans JS.

_ est populaire dans Go. Il est également utilisé dans Dart pour indiquer qu'un paramètre est ignoré et probablement d'autres paramètres que je ne connais pas.

22
Günter Zöchbauer

Il est possible de distinguer les deux utilisations, et certains frameworks l’utilisent pour représenter différents types de callbacks. Par exemple, je pense que le cadre des noeuds express utilise cette fonction pour distinguer les types de middleware. Par exemple, les gestionnaires d'erreur utilisent trois arguments, tandis que le routage en utilise deux.

Une telle différenciation peut ressembler à l'exemple ci-dessous:

const f1 = () => { } // A function taking no arguments
const f2 = _ => { }  // A function with one argument that doesn't use it

function h(ff) { 
  if(ff.length==0) {
    console.log("No argument function - calling directly");
    ff()
  } else if (ff.length==1) {
    console.log("Single argument function - calling with 1");
    ff(1)
  }
}

h(f1)
h(f2)
10
Michael Anderson