Usando la variable _ (guión bajo) con funciones de flecha en ES6 / Typecript

Me encontré con 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 dado que es la única variable, ¿hay alguna razón para preferir el uso de _ sobre:

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

Seguramente esto no puede ser un carácter menos para escribir. La sintaxis () transmite mejor la intención 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 importe, este fue el contexto en el que se utilizó:

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

La razón por la que se puede usar este estilo (y posiblemente la razón por la que 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 aquí se favorece la verbosidad debido a la coherencia.

Si bien las funciones de flecha permiten un solo parámetro sin paréntesis, es inconsistente con cero, solo desestructurado, 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 se corrigió elis declared but never used error en TypeScript 2.0 para los parámetros subrayados, _también puede activar una unused variable/parameteradvertencia de un linter o IDE. Este es un argumento considerable en contra de hacer esto.

_se puede usar convencionalmente para parámetros ignorados (como la otra respuesta ya se explicó). Si bien esto puede considerarse aceptable, este hábito puede resultar en un conflicto con el _espacio de nombres de subrayado / Lodash, también parece confuso cuando hay varios parámetros ignorados. Por esta razón, es beneficioso tener los parámetros subrayados correctamente nombrados (admitidos en TS 2.0), también ahorra tiempo en descubrir 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 un atajo):

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

Por las razones enumeradas anteriormente, personalmente consideraría el _ => { ... }estilo del código como un mal tono que debería evitarse.

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 función .lengthes 0.

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

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

Supongo que _ =>se acaba de usar () =>porque _es común en otros lenguajes donde no se permite simplemente 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.

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

Dicha diferenciación puede parecerse al ejemplo siguiente:

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

Cuando escribí la publicación, tenía la impresión de que _era la única forma de crear funciones de flecha sin ellas (), lo que me llevó a creer que el uso _podría tener algunas ventajas menores, pero estaba equivocado. @Halt ha confirmado en los comentarios que se comporta como otras variables, no es una construcción de lenguaje especial.

Quiero mencionar una cosa más de la que me di cuenta acerca de estas funciones de flecha de subrayado mientras me probaba a mí mismo que no encontré mencionado en ninguna parte. Usted puede utilizar el subrayado en la función como un parámetro , aunque este uso probablemente no se pretende ya que se supone que representa un parámetro no utilizado. Para mayor claridad, realmente no recomendaría usarlo de esta manera. pero puede ser útil saber para cosas como codegolf , desafíos donde escribes el código más corto (resulta que puedes usar cualquier carácter sin él ()). Podría imaginar algunos casos de uso reales en los que las bibliotecas usan esto y usted necesita usarlo incluso si no tenían la intención de esa funcionalidad.

Ejemplo:

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

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

Probado con la consola Chrome, versión 76.0.3809.132 (compilación oficial) (64 bits)