Utilisation de la variable _ (trait de soulignement) avec des fonctions fléchées dans ES6 / Typescript

Je suis tombé sur cette construction dans un exemple angulaire et je me demande pourquoi cela est choisi:

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

Je comprends que la variable _ signifie que je ne me soucie pas / n'est pas utilisé, mais comme c'est la seule variable, y a-t-il une raison de préférer l'utilisation de _ à:

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

Il ne peut certainement pas s'agir d'un caractère de moins à taper. La syntaxe () transmet 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 importerait, c'était le contexte dans lequel il a été utilisé:

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

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

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

Alors que les fonctions fléchées autorisent un seul paramètre sans parenthèses, il est incompatible avec zéro, un seul déstructuré, un seul 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'une is declared but never usederreur ait été corrigée dans TypeScript 2.0 pour les paramètres soulignés, elle _peut également déclencher un unused variable/parameteravertissement à partir d'un linter ou d'un IDE. C'est un argument considérable contre cela.

_peut être classiquement utilisé pour les paramètres ignorés (comme l'autre réponse déjà expliqué). Bien que cela puisse être considéré comme acceptable, cette habitude peut entraîner un conflit avec l' _espace de noms Underscore / Lodash, cela semble également déroutant lorsqu'il y a plusieurs paramètres ignorés. Pour cette raison, il est avantageux d'avoir des paramètres soulignés correctement nommés (pris en charge dans TS 2.0), permet également de gagner du temps sur la détermination de la signature de la fonction et sur la raison pour laquelle les paramètres sont marqués comme ignorés (cela va à l'encontre de l'objectif du _paramètre en tant que raccourci):

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

Pour les raisons énumérées ci-dessus, je considérerais personnellement le _ => { ... }style de code comme une mauvaise tonalité à éviter.

La ()syntaxe transmet mieux l'intention à mon humble avis et est également plus spécifique au type

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

Si vous utilisez _, il indique explicitement que la fonction recevra un argument, mais que vous ne vous en souciez pas. La fonction .lengthsera 1, ce qui peut être important dans certains cadres.

Donc, du point de vue du type, il peut être plus précis de le faire (surtout lorsque vous ne le tapez pas avec anymais, disons, _: Event). Et comme vous l'avez dit, c'est un caractère de moins à taper, ce qui est également plus facile à atteindre sur certains claviers.

Je suppose que _ =>c'est juste utilisé () =>parce que _c'est courant dans d'autres langues où il n'est pas autorisé à simplement omettre des paramètres comme dans JS.

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

Il est possible de faire la distinction entre les deux usages, et certains frameworks l'utilisent pour représenter différents types de callbacks. Par exemple, je pense que le cadre express de nœuds utilise cela pour distinguer les types de middleware, par exemple, les gestionnaires d'erreurs 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);

Quand j'ai écrit le post, j'avais l'impression que _c'était le seul moyen de créer des fonctions fléchées sans (), ce qui m'a amené à croire que l'utilisation _pouvait avoir des avantages mineurs, mais je me suis trompé. @Halt a confirmé dans les commentaires qu'il se comporte comme les autres variables, ce n'est pas une construction de langage spéciale.

Je veux mentionner une autre chose que j'ai réalisée à propos de ces fonctions de flèche de soulignement en me testant, je n'ai trouvé mentionné nulle part. Vous pouvez utiliser le trait de soulignement dans la fonction en tant que paramètre , bien que ce ne soit probablement pas l'usage prévu car il est censé représenter un paramètre inutilisé. Pour plus de clarté, je ne recommanderais pas vraiment de l'utiliser de cette façon. mais il peut être utile de savoir pour des choses comme codegolf , des défis où vous écrivez le code le plus court (il s'avère que vous pouvez simplement utiliser n'importe quel caractère sans ()). Je pourrais imaginer des cas d'utilisation réels où les bibliothèques l'utilisent et vous devez l'utiliser même si elles n'ont pas l'intention d'utiliser cette fonctionnalité.

Exemple:

// simple number doubling function
f = _=> {
    _ = _ * 2;
    return _;
}

console.log(f(2)); // returns 4
console.log(f(10)); // returns 20

Testé avec la console Chrome, version 76.0.3809.132 (version officielle) (64 bits)