Usando la variabile _ (trattino basso) con le funzioni freccia in ES6 / Typescript

Mi sono imbattuto in questo costrutto in un esempio angular e mi chiedo perché questo è scelto:

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

Capisco che la variabile _ significa non si cura / non è usata ma poiché è l’unica variabile c’è qualche ragione per preferire l’uso di _ over:

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

Sicuramente questo non può riguardare un personaggio in meno da digitare. La syntax () trasmette meglio l’intento a mio avviso ed è anche più specifica del tipo, perché altrimenti penso che il primo esempio avrebbe dovuto assomigliare a questo:

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

Se è 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 usato (e probabilmente perché è stato usato qui) è che _ è un carattere più corto di () .

Le parentesi opzionali rientrano nello stesso problema di stile delle parentesi graffe opzionali . Questa è una questione di gusti 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, non è coerente con zero, singolo destrutturato, singolo rest e più parametri:

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

Sebbene is declared but never used errore in TypeScript 2.0 per i parametri sottolineati, _ può anche triggersre avvisi di unused variable/parameter da un linter o da un IDE. Questo è un argomento considerevole contro questo.

_ può essere usato in modo convenzionale per i parametri ignorati (come già spiegato dall’altra risposta). Anche se questo può essere considerato accettabile, questa abitudine potrebbe causare un conflitto con lo spazio dei nomi _ Underscore / Lodash, anche apparire confuso quando ci sono più parametri ignorati. Per questo motivo è utile avere dei parametri underscored opportunamente denominati (supportati in TS 2.0), inoltre consente di risparmiare tempo nella determinazione della firma della funzione e del motivo per cui i parametri sono contrassegnati come ignorati (ciò sfugge allo scopo del parametro _ come scelta rapida):

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

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

La syntax () trasmette l’intento meglio imho ed è anche più specifica del testo

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

Se usi _ , afferma esplicitamente che la funzione verrà passata a un argomento, ma che non ti interessa. La .length della funzione sarà 1, 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 lo si digita con any , ad esempio, _: Event ). E come hai detto, è un carattere in meno da digitare, che è anche più facile da raggiungere su alcune tastiere.

Immagino che _ => sia appena usato over () => perché _ è comune in altre lingue dove non è permesso solo omettere parametri come in JS.

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

È ansible distinguere tra i due usi, e alcuni framework usano questo per rappresentare diversi tipi di callback. Ad esempio, ritengo che nodes express framework utilizzi questo per distinguere tra tipi di middleware, ad esempio i gestori degli errori utilizzano tre argomenti, mentre il routing ne utilizza due.

Tale differenziazione può apparire come nell’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)