javascript - sintaxis - Uso de la variable_(guión bajo) con funciones de flecha en ES6/Typecript

map javascript

Question

Encontré esta construcción en un ejemplo angular y me pregunto por qué se elige esto:

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

Entiendo que la variable _ significa que no me importa / no se usa, pero como es la única variable, ¿hay alguna razón para preferir el uso de _ sobre:

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

Seguramente no puede tratarse de un personaje menos para escribir. La sintaxis () transmite la intención mejor en mi opinión y también es más específica del tipo porque, de lo contrario, creo que el primer ejemplo debería haberse visto así:

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

En caso de que sea importante, este fue el contexto en el que se utilizó:

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

Answer 1

La sintaxis () transmite la intención mejor en mi humilde opinión y también es más específica del tipo

No exactamente. () dice que la función no espera ningún argumento, no declara ningún parámetro. La .length la función es 0.

Si usa _ , declara explícitamente que la función pasará un argumento, pero que no le importa. La .length la función será 1, lo que puede ser importante en algunos marcos.

Por lo tanto, desde una perspectiva de tipo, podría ser algo más preciso que hacer (especialmente cuando no lo escribe con any pero, digamos, _: Event ). Y como dijiste, es un carácter menos para escribir, que también es más fácil de alcanzar en algunos teclados.

Answer 2

Es posible distinguir entre los dos usos, y algunos marcos lo usan para representar diferentes tipos de devoluciones de llamada. Por ejemplo, creo que el framework express de nodos usa esto para distinguir entre tipos de middleware, por ejemplo, los manejadores de errores usan tres argumentos, mientras que el enrutamiento usa dos.

Tal diferenciación puede parecerse al siguiente ejemplo:

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)

Answer 3

La razón por la que se puede usar este estilo (y posiblemente por qué se usó aquí) es que _ es un carácter más corto que () .

Los paréntesis opcionales caen en el mismo problema de estilo que los corchetes opcionales . Esto es una cuestión de gusto y estilo de código en su mayor parte, pero la verbosidad se ve favorecida aquí debido a la consistencia.

Si bien las funciones de flecha permiten un único parámetro sin paréntesis, es inconsistente con cero, un solo desestructurado, un solo descanso y múltiples parámetros:

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

Aunque el error is declared but never used se corrigió en TypeScript 2.0 para los parámetros subrayados, _ también puede activar unused variable/parameter advertencia de unused variable/parameter desde un linter o IDE. Este es un argumento considerable en contra de hacer esto.

_ puede usarse convencionalmente para parámetros ignorados (como ya se explicó en la otra respuesta). Si bien esto puede considerarse aceptable, este hábito puede generar un conflicto con el espacio de nombres _ subrayado / Lodash, también parece confuso cuando hay múltiples parámetros ignorados. Por esta razón, es beneficioso nombrar correctamente los parámetros subrayados (admitidos en TS 2.0), también ahorra tiempo en averiguar la firma de la función y por qué los parámetros se marcan como ignorados (esto desafía el propósito del parámetro _ como acceso directo):

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

Por las razones mencionadas anteriormente, personalmente consideraría que el estilo de código _ => { ... } un mal tono que debe evitarse.

Answer 4

Supongo que _ => solo se usa sobre () => porque _ es común en otros idiomas donde no está permitido omitir parámetros como en JS.

_ es popular en Go y también se usa en Dart para indicar que se ignora un parámetro y probablemente otros que no conozco.