Una nota sobre vacío en JavaScript y TypeScript

Si, antes de interesarse en JavaScript, escribió en lenguajes tradicionales con un tipeo fuerte, entonces puede estar familiarizado con el concepto de void . Este es el tipo cuyo uso le dice al programador que las funciones y métodos correspondientes no devuelven nada cuando se les llama.



La entidad void también está disponible en JavaScript y TypeScript. En JS, este es un operador. En TS, este es un tipo de datos primitivo. Y aquí y allá, void no se comporta como muchos de los que encontraron void en otros idiomas esperarían.

Declaración nula de JavaScript

En JavaScript, el operador void evalúa la expresión que se le pasa. Al mismo tiempo, no importa qué expresión se evalúe, void siempre devuelve undefined .

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

¿Por qué necesitamos un operador así?
En primer lugar, debe tenerse en cuenta que en los primeros años de la programación JS, los desarrolladores podían redefinir lo undefined y escribirle algún valor. Pero void siempre devuelve el verdadero valor de undefined .

En segundo lugar, usar el operador void es una forma interesante de trabajar con funciones llamadas de inmediato:

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

Y todo esto, sin contaminación del espacio de nombres global:

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

Dado que el operador void siempre devuelve undefined y siempre evalúa la expresión que se le pasa, tenemos una forma muy expresiva de regresar de la función sin devolver algún valor, pero con una llamada, por ejemplo, alguna devolución de llamada:

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

Esto nos lleva a la forma más importante de usar void . Este operador es una especie de aplicación de "puesto de guardia". Si una determinada función siempre debe volver undefined , esto se puede lograr utilizando el operador void .

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

Tipo de datos nulo en TypeScript

El tipo void en TypeScript se puede llamar algo así como lo contrario de type any . Las funciones en JavaScript siempre devuelven algo. Este puede ser un valor establecido por el programador o undefined :

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

Dado que las funciones de JavaScript, de las cuales no se devuelve nada explícitamente, siempre devuelven undefined , void en TypeScript es el tipo apropiado para indicar a los desarrolladores que la función devuelve undefined

 declare function iHaveNoReturnValue(i: number): void 

La entidad void en forma de tipo también se puede usar para parámetros y para cualquier otra declaración de variable. El único valor que siempre se puede pasar al parámetro vacío undefined está undefined .

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

Como resultado, resulta que en TS los tipos void e undefined son casi lo mismo. Pero hay una pequeña diferencia entre ellos, que, de hecho, es extremadamente importante. El tipo void devuelto se puede reemplazar con otros tipos, lo que le permite implementar patrones avanzados para trabajar con devoluciones de llamada.

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

Los desarrolladores esperan que tales diseños, a menudo utilizados en aplicaciones JS, hagan exactamente eso. Aquí está el material sobre este tema.

Si desea que una función acepte solo funciones que devuelven undefined , puede cambiar la firma del método en consecuencia:

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

Resumen

El operador void en JavaScript y el tipo de datos void en TypeScript son entidades bastante simples. La gama de situaciones en las que son aplicables es limitada. Sin embargo, debe tenerse en cuenta que el programador que los usa, muy probablemente, no encontrará ningún problema al trabajar con ellos.

Estimados lectores! ¿Usas void en JS y TS?