A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Void y never

11/32
Recursos

Aportes 50

Preguntas 8

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

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 鈥渁ny鈥 en vez de 鈥渧oid鈥 ahora explico. Una funci贸n al declararla de manera inferencial por lo general se encuentra con el tipo 鈥渁ny鈥:

// 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

Yo usar铆a void, en el escenario de crear una funci贸n logger, tal como la libreria 'debug', que la llamas y ejecuta la acci贸n de hacer un log con un namespace. Y Never, en el escenario de construir un errorHandler o una funci贸n de un reloj que se mantiene ejecutando. como este ejemplo: https://www.w3schools.com/js/tryit.asp?filename=tryjs_timing_clock
  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

<h5>Tipo Void</h5>
  • void es lo opuesto de any, representa la ausencia de tipo
  • Com煤nmente se usa como tipo de retorno en funciones
<h5>Tipo Never</h5>
  • 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 鈥榟ola鈥; 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

A lo que entiendo *void* puede quiza regresar un valor, *never* nunca va a regresar un valor

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.