Utilizzo della variabile _ (trattino basso) con funzioni freccia in ES6 / Typescript

Mi sono imbattuto in questo costrutto in un esempio angolare e mi chiedo perché sia ​​stato scelto:

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

Capisco che la variabile _ significa non importa / non usata ma poiché è l'unica variabile c'è qualche motivo per preferire l'uso di _ rispetto a:

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

Sicuramente questo non può essere di circa un carattere in meno da digitare. La sintassi () trasmette meglio l'intento secondo me ed è anche più specifica per tipo perché altrimenti penso che il primo esempio avrebbe dovuto assomigliare a questo:

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

Nel caso fosse importante, questo era il contesto in cui è stato utilizzato:

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

Il motivo per cui questo stile può essere utilizzato (e forse perché è stato usato qui) è che _è un carattere più corto di ().

Le parentesi facoltative rientrano nello stesso problema di stile delle parentesi graffe facoltative . Questa è una questione di gusto e stile di codice per la maggior parte, ma la verbosità è favorita qui a causa della coerenza.

Mentre le funzioni freccia consentono un singolo parametro senza parentesi, è incoerente con zero, singola destrutturata, singola pausa e più parametri:

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

Sebbene l' is declared but never usederrore sia stato corretto in TypeScript 2.0 per i parametri sottolineati, _può anche attivare un unused variable/parameteravviso da un linter o da un IDE. Questo è un argomento considerevole contro questa operazione.

_può essere convenzionalmente utilizzato per parametri ignorati (come l'altra risposta già spiegata). Sebbene questo possa essere considerato accettabile, questa abitudine può provocare un conflitto con _lo spazio dei nomi Underscore / Lodash, inoltre sembra confuso quando ci sono più parametri ignorati. Per questo motivo è vantaggioso disporre di parametri sottolineati correttamente denominati (supportati in TS 2.0), inoltre consente di risparmiare tempo nel capire la firma della funzione e il motivo per cui i parametri sono contrassegnati come ignorati (questo sfida lo scopo del _parametro come scorciatoia):

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

Per i motivi sopra elencati, personalmente considererei lo _ => { ... }stile del codice un brutto tono che dovrebbe essere evitato.

La ()sintassi trasmette meglio l'intento ed è anche più specifica per il tipo

Non esattamente. ()dice che la funzione non si aspetta alcun argomento, non dichiara alcun parametro. La funzione .lengthè 0.

Se lo usi _, afferma esplicitamente che alla funzione verrà passato un argomento, ma che non ti interessa. La funzione .lengthsarà 1, il che potrebbe essere importante in alcuni framework.

Quindi, dal punto di vista del tipo, potrebbe essere una cosa più accurata da fare (specialmente quando non la digiti con anyma, diciamo, _: Event). E come hai detto, è un carattere in meno da digitare, che è anche più facile da raggiungere su alcune tastiere.

Immagino _ =>sia solo usato () =>perché _è comune in altre lingue in cui non è consentito omettere solo parametri come in JS.

_ è popolare in Go ed è utilizzato anche in Dart per indicare che un parametro viene ignorato e probabilmente altri che non conosco.

È possibile distinguere tra i due utilizzi e alcuni framework lo utilizzano per rappresentare diversi tipi di callback. Ad esempio, penso che il framework Nodes Express lo utilizzi per distinguere tra i tipi di middleware, ad esempio i gestori di errori utilizzano tre argomenti, mentre il routing ne utilizza due.

Tale differenziazione può essere simile all'esempio seguente:

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

Quando ho scritto il post avevo l'impressione che _fosse l'unico modo per creare funzioni freccia senza (), il che mi ha portato a credere che l'utilizzo _potesse avere alcuni piccoli vantaggi, ma mi sbagliavo. @Halt ha confermato nei commenti che si comporta proprio come le altre variabili, non è un costrutto di linguaggio speciale.

Voglio menzionare un'altra cosa che ho realizzato su queste funzioni di sottolineatura della freccia mentre mi provavo che non ho trovato menzionato da nessuna parte. È possibile utilizzare il carattere di sottolineatura nella funzione come parametro , sebbene questo probabilmente non sia un utilizzo previsto poiché dovrebbe rappresentare un parametro inutilizzato. Per chiarezza, non consiglierei davvero di usarlo in questo modo. ma può essere utile sapere per cose come codegolf , sfide in cui scrivi il codice più breve (si scopre che puoi usare qualsiasi carattere senza ()). Potrei immaginare alcuni casi d'uso reali in cui le biblioteche lo usano e devi usarlo anche se non intendevano per quella funzionalità.

Esempio:

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

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

Testato con la console Chrome, versione 76.0.3809.132 (build ufficiale) (64 bit)