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

Question

Je suis tombé sur cette construction dans Angulaire exemple et je me demande pourquoi ce est choisi:

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

Je comprends que la variable _ les moyens de ne pas les soins/pas utilisé mais depuis c'est la seule variable est-il une raison pour préférer l'utilisation d' _ dessus:

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

Assurément, ce ne peut pas être sur un caractère moins de type. () La syntaxe exprime l'intention de mieux à mon avis et il est aussi plus spécifiques de type parce que sinon je pense que le premier exemple devrait ressembler à ceci:

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

En cas de questions, c'était le contexte où il a été utilisé:

submit(query: string): void {
    this.router.navigate(['search'], { queryParams: { query: query } })
      .then(_ => this.search());
}

Answer 1

La raison d'être de ce style peut être utilisé (et éventuellement pourquoi il a été utilisé ici) c'est qu' _ est d'un caractère plus courte que ().

En option parenthèses tomber dans le même style de question comme option d'accolades. C'est une question de goût et de style de code pour la plupart, mais le niveau de verbosité est favorisée ici à cause de la cohérence.

Tandis que la flèche de fonctions qui permettent à un seul paramètre sans parenthèses, il est incompatible avec le zéro, seul déstructuré, seul le repos et plusieurs paramètres:

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

Bien qu' is declared but never used d'erreur a été corrigée dans Tapuscrit 2.0 pour souligné paramètres, _ peut également déclencher unused variable/parameter d'avertissement à partir d'un linter ou IDE. C'est un grand argument contre cela.

_ peut être classiquement utilisé pour ignorés paramètres (comme l'autre réponse déjà expliqué). Même si cela peut être considéré comme acceptable, cette habitude peut entraîner un conflit avec _ de Soulignement/Lodash espace de noms, regarde également source de confusion lorsqu'il y a plusieurs ignoré paramètres. Pour cette raison, il est utile d'avoir bien nommé souligné paramètres (pris en charge dans TS 2.0), permet également d'économiser du temps à comprendre la fonction de signature et pourquoi les paramètres sont marqués comme ignoré (il défie le but d' _ paramètre comme un raccourci):

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

Pour les raisons énumérées ci-dessus, personnellement, je ne considère _ => { ... } code style un mauvais ton qui doit être évitée.

Answer 2

L' () de la syntaxe exprime l'intention de mieux à mon humble avis et il est aussi plus spécifiques de type

Pas exactement. () indique que la fonction ne s'attend pas à des arguments, il ne déclarent pas tous les paramètres. La fonction de l' .length est de 0.

Si vous utilisez _, il est dit explicitement que la fonction va être transmis à un argument, mais que vous ne vous inquiétez pas à ce sujet. La fonction de l' .length 1, qui comptent dans certains cadres.

Donc, à partir d'un type de point de vue, il serait plus exact chose à faire (surtout lorsque vous ne tapez pas il avec any mais, disons, _: Event). Et comme vous l'avez dit, c'est un caractère moins pour le type qui est également la plus facile à atteindre sur certains claviers.

Answer 3

J'imagine que _ => est simplement utilisé par-dessus () => 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.

Answer 4

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)