Usando a variável _ (sublinhado) com funções de seta em ES6 / Typescript

Eu me deparei com essa construção em um exemplo Angular e me pergunto por que isso foi escolhido:

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

Eu entendo que a variável _ significa não me importo / não usado, mas como é a única variável, há alguma razão para preferir o uso de _ em vez de:

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

Certamente isso não pode ser cerca de um caractere a menos para digitar. A sintaxe () transmite melhor a intenção na minha opinião e também é mais específica do tipo, porque caso contrário, acho que o primeiro exemplo deveria ser assim:

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

Caso seja importante, este foi o contexto onde foi usado:

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

A razão pela qual este estilo pode ser usado (e possivelmente porque foi usado aqui) é que _é um caractere mais curto que ().

Os parênteses opcionais têm o mesmo tipo de problema de estilo que as chaves opcionais . Esta é uma questão de gosto e estilo de código na maior parte, mas a verbosidade é favorecida aqui por causa da consistência.

Embora as funções de seta permitam um único parâmetro sem parênteses, é inconsistente com zero, desestruturação única, descanso único e vários parâmetros:

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

Embora o is declared but never usederro tenha sido corrigido no TypeScript 2.0 para parâmetros sublinhados, _também pode disparar um unused variable/parameteraviso de um linter ou IDE. Este é um argumento considerável contra isso.

_pode ser usado convencionalmente para parâmetros ignorados (como a outra resposta já explicada). Embora isso possa ser considerado aceitável, esse hábito pode resultar em um conflito com o _namespace Underscore / Lodash, também parece confuso quando há vários parâmetros ignorados. Por esse motivo, é benéfico ter parâmetros sublinhados corretamente nomeados (com suporte no TS 2.0), também economiza tempo ao descobrir a assinatura da função e por que os parâmetros são marcados como ignorados (isso desafia o propósito do _parâmetro como um atalho):

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

Pelas razões listadas acima, eu pessoalmente consideraria o _ => { ... }estilo de código um tom ruim que deve ser evitado.

A ()sintaxe transmite a intenção melhor imho e também é mais específica do tipo

Não exatamente. ()diz que a função não espera nenhum argumento, ela não declara nenhum parâmetro. A função .lengthé 0.

Se você usar _, ele afirma explicitamente que a função receberá um argumento, mas que você não se importa com isso. A função .lengthserá 1, o que pode ser importante em algumas estruturas.

Então, de uma perspectiva de tipo, pode ser a coisa mais precisa a fazer (especialmente quando você não digita com anymas, digamos, _: Event). E como você disse, é um caractere a menos para digitar, o que também é mais fácil de alcançar em alguns teclados.

Acho que _ =>é usado () =>porque _é comum em outras linguagens onde não é permitido apenas omitir parâmetros como em JS.

_ é popular no Go e também é usado no Dart para indicar que um parâmetro é ignorado e provavelmente outros que não conheço.

É possível distinguir entre os dois usos, e alguns frameworks usam isso para representar diferentes tipos de callbacks. Por exemplo, acho que o framework nodes express usa isso para distinguir entre tipos de middleware, por exemplo, manipuladores de erros usam três argumentos, enquanto o roteamento usa dois.

Essa diferenciação pode ser semelhante ao exemplo abaixo:

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 escrevi o post fiquei com a impressão de que _era a única maneira de criar funções de flecha sem (), o que me levou a acreditar que usar _poderia ter algumas pequenas vantagens, mas me enganei. @Halt confirmou nos comentários que se comporta como outras variáveis, não é uma construção de linguagem especial.

Quero mencionar mais uma coisa que percebi sobre essas funções de seta de sublinhado enquanto me testava e não encontrei mencionado em lugar nenhum. Você pode usar o sublinhado na função como um parâmetro , embora esse provavelmente não seja o uso pretendido, já que ele deve representar um parâmetro não usado. Para maior clareza, eu realmente não recomendo usá-lo dessa forma. mas pode ser útil saber coisas como codegolf , desafios em que você escreve o código mais curto (parece que você pode usar qualquer caractere sem isso ()). Eu poderia imaginar alguns casos de uso reais em que as bibliotecas usam isso e você precisa usá-lo, mesmo que elas não pretendessem ter essa funcionalidade.

Exemplo:

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

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

Testado com o console do Chrome, versão 76.0.3809.132 (versão oficial) (64 bits)