Uma observação sobre o vazio no JavaScript e TypeScript

Se, antes de se interessar por JavaScript, você escreveu em idiomas tradicionais com digitação forte, talvez esteja familiarizado com o conceito de void . Esse é o tipo cujo uso informa ao programador que as funções e métodos correspondentes não retornam nada quando chamados.



A entidade void também está disponível em JavaScript e TypeScript. Em JS, este é um operador. No TS, esse é um tipo de dados primitivo. E aqui e ali, o void não se comporta como muitos daqueles que se depararam com o void em outros idiomas esperariam.

Declaração de void JavaScript

Em JavaScript, o operador void avalia a expressão passada para ele. Ao mesmo tempo, não importa qual expressão seja avaliada, void sempre retorna undefined .

 let i = void 2; // i === undefined 

Por que precisamos desse operador?
Primeiramente, deve-se notar que, nos primeiros anos da programação JS, os desenvolvedores poderiam redefinir undefined e agregar algum valor a ele. Mas void sempre retorna o valor verdadeiro de undefined .

Em segundo lugar, o uso do operador void é uma maneira interessante de trabalhar com funções chamadas imediatamente:

 void function() {  console.log('What') }() 

E tudo isso - sem poluição do espaço para nome global:

 void function aRecursion(i) {  if(i > 0) {    console.log(i--)    aRecursion(i)  } }(3) console.log(typeof aRecursion) // undefined 

Como o operador void sempre retorna undefined e sempre avalia a expressão passada para ele, temos uma maneira muito expressiva de retornar da função sem retornar algum valor, mas com uma chamada, por exemplo, algum retorno de chamada:

 //  -  undefined      function middleware(nextCallback) {  if(conditionApplies()) {    return void nextCallback();  } } 

Isso nos leva à maneira mais importante de usar o void . Esse operador é um tipo de aplicativo "posto de guarda". Se uma certa função sempre retornar undefined , isso pode ser alcançado usando o operador void .

 button.onclick = () => void doSomething(); 

Tipo de dados nulos no TypeScript

O tipo void no TypeScript pode ser chamado de algo como o oposto do tipo any . Funções em JavaScript sempre retornam algo. Este pode ser um valor definido pelo programador ou undefined :

 function iHaveNoReturnValue(i) {  console.log(i) } //  undefined 

Como as funções JavaScript, das quais nada é explicitamente retornado, sempre retornam undefined , o void no TypeScript é o tipo apropriado para informar aos desenvolvedores que a função retorna undefined :

 declare function iHaveNoReturnValue(i: number): void 

A entidade void na forma de um tipo também pode ser usada para parâmetros e para quaisquer outras declarações de variáveis. O único valor que sempre pode ser passado para o parâmetro void é undefined .

 declare function iTakeNoParameters(x: void): void iTakeNoParameters() //  iTakeNoParameters(undefined) //  iTakeNoParameters(void 2) //  

Como resultado, verifica-se que no TS os tipos void e undefined são quase a mesma coisa. Mas há uma pequena diferença entre eles, que, de fato, é extremamente importante. O tipo de retorno retornado pode ser substituído por outros tipos, o que permite implementar padrões avançados para trabalhar com retornos de chamada.

 function doSomething(callback: () => void) {  let c = callback() // callback   undefined  // c -  undefined } //     function aNumberCallback(): number {  return 2; } // ;    doSometing doSomething(aNumberCallback) 

Os desenvolvedores esperam que esses designs, geralmente usados ​​em aplicativos JS, façam exatamente isso. Aqui está o material sobre este tópico.

Se você deseja que uma função aceite apenas funções que retornam undefined , você pode alterar a assinatura do método adequadamente:

 //  // function doSomething(callback: () => void) { //  function doSomething(callback: () => undefined) { /* ... */ } function aNumberCallback(): number { return 2; } //  -    doSomething(aNumberCallback) 

Sumário

O operador void no JavaScript e o tipo de dados void no TypeScript são entidades bastante simples. O intervalo de situações em que são aplicáveis ​​é limitado. No entanto, deve-se notar que o programador que os utiliza, provavelmente, não encontrará problemas ao trabalhar com eles.

Caros leitores! Você usa void em JS e TS?