Void y never

Tipo Void: Representa la ausencia de tipo. usado en funciones que no retornan nada.
Tipo Never: Representa funciones que lanzan excepciones o nunca retornan un valor.

Código de la clase:

// type void for functions
// Explicit type

function showInfo(user: any): any {
  console.log(`User Info ${user.id} ${user.username} ${user.firstname}`);
  //   return 'hola';
}

showInfo({id: 1, username: 'Antúnez Durán', firstname: 'Francisco Javier'});

// Inferred type
function showFormattedInfo(user: any) {
  console.log(`User Info,
        id: ${user.id}
        username: ${user.username}
        firstname: ${user.firstname}`);
}

showFormattedInfo({id: 1, username: 'Antúnez Durán', firstname: 'Francisco Javier'});

// Type void as variable data type
let unusable: void;
// unusable = null; --> colocar "strict": false en tsconfig.json para poder hacer uso
unusable = undefined;

// Type never
function handleError(code: number, message: string): never {
  // Process your code
  // Generate a message
  throw new Error(`${message}. Code: ${code}`);
}

try {
  console.log('La funcion handleError no devuelve nada bajo esta linea');
  handleError(404, 'Not found');
} catch (error) {}

function sumNumbers(limit: number): never {
  let sum = 0;
  while (true) {
    sum++;
  }
  // return sum;
}

sumNumbers(10); // --> Llamada a un bucle infinito no acabaria nunca, typescript no compila, al verlo.

Tipo Void: Son funciones que no necesitan de un retorno, por lo que al asignar el tipo void se sobre entiende que estas funciones retornan un undefind o un valor no definido, mas si permiten el uso de este return con este valor, que en el futuro puede ser usado para la terminacion de una funcion de este tipo.

Tipo Never: En este caso son funciones que nunca retornaran un valor, dentro de TS si intentas retornar un valor en una funcion Never te marcara error, normalmente usada para errores ya que son funciones que no retornan un valor sino que lanzan o arrojan un error o mensaje al ejecutarse, cabe destacar tambien que las variables declaradas como nulas no permiten que se les asigne ningun tipo de dato, caso contrario a los void que permite la asignacion del dato undefind

El declarar una función como void o never, a efectos de resultado, produce el mismo. El tipo void lo tengo claro, en cambio a never no le veo a utilidad como tal.

Un poco confuso a la primera pero ya lo tengo casi entendido.

Para los que se pregunten porque pone “any” en vez de “void” ahora explico. Una función al declararla de manera inferencial por lo general se encuentra con el tipo “any”:

// Es como tener tipo :any, pero
// como no retorna nada lo asigna a tipo :void

function unaFuncion() {
	// Código...
}

y cuando no retorna un valor esta función, la inferencia que hara typescript sera ponerla en tipo void

// Si asignamos :any va a pasar lo mismo 
// que en las variables y podemos retornar
// cualquier tipo de valor ya sea un string,
// boolean, etc., o no retornar nada.

function unaFuncion(): any {
	console.log("Hola mundo")
}

por esa razón el profesor pone de tipo any en la función para que pueda retornar o no retornar un valor.

No sé si fue que me perdí pero creo que al rededor del minuto 3:37 hubo un error porque estábamos viendo la declaración de que la función no retorna un valor dándole como tipo de retorno void y se colocó fue any :S

1. Void. Este tipo es lo opuesto al tipo anterior ya que representa la ausencia de tipo, es utilizado comúnmente como el tipo de retorno en funciones.

   // Explícito
   function showInfo (user: any): void {
     console.log('User info', user.id, user.userName, user.firstName)
   }
   
   showInfo({ id: 1, username: 'Alex', firstName: 'Alejandra' })
   

   También podemos trabajar con variables tipo void, estas variables solo aceptan valores null o undefined.

2. Never. Es un tipo de dato especial en TypeScript, representa el tipo de valor que nunca ocurre, puede ser usado en funciones que lanzan excepciones o en funciones que nunca retornan un valor.

   function handleError (code: number, message: string): never {
     // Process your code here
     // Generate a message
     throw new Error(`${message}. Code: ${code}`)
   }
   

Estaría bien poder conocer con ejemplos algo mas prácticos, el uso de Void y sobre todo de Never, en el saber que no espero, la devolución de un dato, en un función miFuncion()… que importancia tiene colocare o no el : never.

Void y Never

• void es lo opuesto de any, representa la ausencia de tipo
• Comúnmente se usa como tipo de retorno en funciones

• Representa el tipo de valor que nunca ocurre
  • Funciones que lanzan excepciones
  • Funciones que nunca retornan un valor

Void, ausencia de valor, retorno nulo en las funciones, una variable con este tipo & asigarle null/undefined
Never, Valor que no ocurre, cuando se lanzan excepciones.

Debi{o haber colocado void en lugar de any en el primer ejemplo

excelente! nunca pense lo util que pudiera ser Typescript, ya no me da miedo 😂

Esta clase confunde un poco, ibamos a ver void y never pero comenzamos con any(?) que era de la clase pasada

Cuál es el objetivo o ventaja de utilizar o no never?

Bueno, lo entiendo pero no veo en que punto usarlo, creo que habrá que practicarlo más para saber en que punto puedo llegar a implementarlo.

Que buena explicación, se me hacían muy raros los never y void pero ya les veo algo mas de sentido

Casos de pruebas unitarias para evaluar lo que el profesor indica en la clase

import { showInfo, showFormattedInfo, handleError } from "../src/void";
describe("Suite test for void objects", () => {
  afterEach(() => {
    jest.resetAllMocks();
  });
  test("Should execution function without return", () => {
    const expectResult: string = "User Info 1, zearkiatos, Pedro";
    const consoleSpy = jest.spyOn(console, "log");
    const user: any = {
      id: 1,
      username: "zearkiatos",
      firstName: "Pedro"
    };

    showInfo(user);

    expect(consoleSpy).toHaveBeenCalled();
    expect(consoleSpy.mock.calls[0][0]).toBe(expectResult);
  });

  test("Should execution function without return and with some formatter", () => {
    const expectResult: string = `
    id: 2
    username: zearkiatos
    firstName: Pedro`;
    const consoleSpy = jest.spyOn(console, "log");
    const user: any = {
      id: 2,
      username: "zearkiatos",
      firstName: "Pedro"
    };

    showFormattedInfo(user);

    expect(consoleSpy).toHaveBeenCalled();
    expect(consoleSpy.mock.calls[0][1]).toBe(expectResult);
  });

  test("Should use Never with a manage an error function", () => {
    const code: number = 404;
    const message: string = "Not Found";
    const expectResult: string = "Not Found. Code: 404";

    try {
      expect(handleError(code, message)).toThrow();
    } catch (ex: any) {
      expect(ex.message).toBe(expectResult);
    }
  });
});

Repo

En el codigo que se muestra y el que esta para descargar el retorno es : **any ** cuando en realidad se esta haciendo referencia a void. Sin comentar el return ‘hola’; de la primer funcion se define any el IDE no da error, asumo porque al ser any puede retornar cualquier valor o ninguno. En cambio usando void si da error el IDE y también el compilador. Es void lo que debe usarse para la declaración explicita de función que no retorna valor.

No tengo muy claro cuando usar void y cuando usar never, por los ejemplos las veo iguales.

void se usa siempre que una función no devuelve nada explícitamente (generalmente eso significa que devuelve undefined implícitamente) y never cuando una función nunca retorna.

Tipo Void:

• Representa la ausencia de tipo (opuesto a Any).
• No tiene sentido usar este tipo en la declaracion de variables
• Usado en funciones que no retornan nada.

Tipo Never:

• Representa funciones que lanzan excepciones o nunca retornan un valor.

se me hace mas fácil entenderlo como Explicito e Implícito que usar la palabra inferido.

Si se usa el tipo void en variables, solamente se le puede asignar undefined a dicha variable.

Void es lo opuesto de Any:

• Representa la ausencia de tipo

• Comúnmente se usa como tipo de retorno en funciones

Tipo Never

Tipo void en variables

Que gran profe

Tipo never

MY NOTES VOID AND NEVER

• void es lo opuesto de any representa la ausencia de tipo
• Comúnmente se usa como tipo de retorno en funciones

//Void
  //Tipo Explicito que tambien aplica a funciones
    //Si la funcion no retorna ningun tipo de dato la funcion tendria como tipo de dato void
      //Pero si retorna algun dato le asigna ese tipo de dato a la funcion
  function showInfo(user: any){
    console.log('User Info', user.id, user.username, user.firstName);
  }

  showInfo({id:1, username:'andres22', firstName:'andres pinchao' });

  //Tipo Inferido

  function showFormattedInfo(user:any){

    console.log('User Info',`
      id: ${user.id}
      username: ${user.username}
      firstName: ${user.firstName}
    `);

  }

  showFormattedInfo({id:1, username:'andres22', firstName:'andres pinchao' });

  //tipo void, como tipo de dato en variable
  let unusable: void;
  // unusable = null;  no puede ser asignado con tipo void
  unusable = undefined;

Tipo : Never

• Representa el tipo de valor que nunca ocurre
  • Funciones que lanzan excepciones
  • Funciones que nunca retornan un valor

// Tipo de Dato Never
  //Indicamos que la funcion nunca retornara utilizando never despues del parentesis de nuestros parametros
function handleError(code:number, message:string) :never{

    //Procesamiento el codigo
    //Generamos un mensaje
    throw new Error(`${message}. Code ${code}`);

}
//Si enfocamos el cursor en la invocacion nos dice que nunca retorna un resultado
handleError(22, 'andres en platzi master :D');

function sumNumbers(limit:number):never{

    let sum = 0
    while(true){
      sum++
    }
}
//ciclo infinito, el programa nunca termina
sumNumbers(10);

El tipo VOID garantiza que la función no retornará ningún valor (return). En cuanto a NEVER pareciera que no tiene sentido su uso.

• Void: Es el tipo opuesto a Any. Es la ausencia de valor y no tiene sentido su uso en declaración de variables - Pero sí en el retorno de las funciones, comunmente cuando no existe un valor en el retorno
  .
  

  

• Never: Representa el tipo de valor que NUNCA ocurre o se va a dar en el código - Se usa en funciones de excepción o Error en el ámbito del proyecto - Cuadnola función tiene un ciclo infinito y no permite que se finalice.
  ** Se puede usar para gestionar un error y no arrojar nada (devovler algo)
  **

function handleError(code: number, message: string): never {
    // process code

    // return message
    throw new Error(`${message}. Code: ${code}`);
}
try {
    handleError(404, 'Not found')
} catch (error) {
    console.log(`este es el error -> ${error}`)
}


function sumNumber(limit: number) {
    let sum = 0;
    while(true) {
        sum ++;
    }
    return sum  
    //  Esto nunca va a ocurrir! pues es un ciclo infinito, el valor de sum jamás de va a retornar
}
sumNumber(10);

Adapté la función de handleError para que arrojara algo… Si lo compilan, devuelve el error en el catch.
Por otro lado tal como muestra el Profesor, se bloquea la consola con sumNumber.

.
Contestando al Profesor, no tengo una idea clara aún de como usarlo dentro de un proyecto actual de JS. En mi trabajo ya había seteado todo y las reglas para que quizá eso no ocurra. Lo siento : /

El tipo void es prácticamente el opuesto al tipo any. Significa la ausencia de cualquier tipo. Por lo tanto, la variable del tipo void solo puede tener el valor nullsi la configuración --strictNullChecks no se especifica al ejecutar el compilador TypeScrip o si se puede establecer en undefined.

Por lo tanto, asignar valores directamente a una variable void no es muy útil. Se usa más para especificar el tipo de datos de retorno de una función. Una función que tiene el tipo void de retorno no devuelve nada.

**Never: ** Funciones que nunca termina, como un bucle infinito o un error.

function throwError (): never{
  throw new Error(`Hello! I'm an error`)
}

function infLoop(): never{
  while(true){
  }
}

**Void: ** Funciones que no retornan nada, pero terminan su flujo.

function sayHello(): void{
  console.log('Hello!');
}

Tipo de dato Never

Tipo de dato Void

En el último ejemplo a la función sumNumbers le pasa el numero 10 que corresponde al parámetro limit, el cual nunca es usado porque se supone que es un ciclo infinito.

No sé si fue que me perdí pero creo que en este punto hubo un error porque estábamos viendo la declaración de que la función no retorna un valor dándole como tipo de retorno void y se colocó fue any :S

void es lo opuesto de any: representa la ausencia de tipo. Comúnmente se usa como tipo de retorno en funciones.

Tipo Void: no retorna ningún valor y asignado para una función.

Tipo Never: nunca va a retornar un error

No entiendo por qué en las funciones iniciales sólo usó y habló de any si lo que estaba explicando era void (y void nunca lo usó explícitamente en las funciones).

Type: Void
Is the opposite to Any, it minds the absence of value.
Normally used to specify the type of data return in functions.
Also you can use Void type to save variables with value null or undefined.

Interesante, espero poder usarla en un manejador de errores, la de tipo never

• Void

  • Void es lo opuesto a any
  • comunmente utilizado para declarar funciones que no necesitan retornar ningun valor

  Sintaxis:

function showInfo(user: any): void {
	console.log(user)
}

• Never

  • representa un valor que nunca ocurre

    • funciones que lanzan excepciones
    • funciones que nunca pueden finalizarse

    Sintaxis:

    // Type never
    function handleError(code: number, message: string): never {
      // Process your code
      // Generate a message
      throw new Error(`${message}. Code: ${code}`);
    }
    

Hello, compis! Realmente me ayudaron a entender más void, ya que, aunque no parece complejo, tiene su grado de dificultad.
Si bien es cierto, no consigo encontrarle ninguna manera práctica de utilizarlo en el código.
¿Ustedes se han encontrado utilizándolo de alguna manera en proyectos prácticos?

el tipo never es algo mas formal pero que no impacta tanto en el resultado final.

/* void */
/* Tipo explicito */

function showInfo(user : any) : void {
    console.log('userInfo',user.id,user.name);
    //return 'hola';
}

showInfo({id:1,name:'fede'});

/* Tipo Inferido */
function showFormattedInfo(user:any){
    console.log('userInfo',`
        id: ${user.id} 
        userName : ${user.name}
    `);
}

showFormattedInfo({id:1,name:'fede'});

/* Tipo Void como tipo de dato en variable */

let unusable: void;
//unusable = null;
//unusable = undefined


/* Tipo never */ 
/* Representa un valor que nunca ocurre */

function handleError (code:number, message:string) : never {
    
    // Procesamiento del codigo 
    // Generamos mensaje
    throw new Error(`${message}. Code ${code}`);
}
try {
    handleError(404,'NotFound');
}
catch(error){}

El tipo de dato** never** es utilizado cuando sabemos que nunca va a haber un valor de retorno. Es más comprensible en el siguiente ejemplo:

function infiniteLoop(): never {
    while (true) {
    }
    return 'this will never execute';
}

Estamos definiendo nuestra función con un valor never. En dicho caso jamás se va a retornar el valor de la línea 4.