No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Never type

6/22
Recursos

El never type se usa para funciones que nunca van a terminar o que detienen el programa. Con esto TypeScript nos ayuda a detectarlos como por ejemplo un ciclo infinito cuando lanzamos un mensaje de error.

Never type en funciones infinitas

En el siguiente c贸digo, TypeScript infiere que el tipo es never, ya que su ejecuci贸n ser谩 infinita.

const withoutEnd = () => {
	while (true) {
		console.log('Nunca parar de aprender');
	}
}

Never vs. Void

Las funciones del tipo void son aquellas que no retornan ning煤n dato, simplemente ejecutan las instrucciones dentro del bloque de la funci贸n. Por tanto, no debemos confundirlas con las de tipo never:

const voidFunc = () => {
  for(let i = 1; i <= 5; i++){
    console.log(i)
  }
}

voidFunc()

/*
// Funci贸n infinita y de tipo Never 馃憞
const neverFunc = () => {
	while (true) {
		console.log('Nunca parar de aprender');
	}
}
*/

Never type en c贸digo con errores

Una funci贸n tambi茅n puede ser del tipo never cuando tenemos un throw que lance un error y, como resultado, haga detener la ejecuci贸n.

const fail = (message: string) => { // TypeScript infiere que esta funci贸n se de tipo `never`
  throw new Error(message)
}

const example = (input:unknown) => {
  if(typeof input === 'string'){
    return 'Es un string';
  }
  else if (Array.isArray(input)){
    return 'Es un array';
  }
  return fail('Not Match'); // Lanzamos un error
}

console.log(example('Hola')) //'Es un string'
console.log(example([1,1,1,1])) // 'Es un array'
console.log(example(1212)) // error: Uncaught Error: Not Match
console.log(example('Hola despu茅s del fail')) // NUNCA SE EJECUTA, porque se lanz贸 un error previamente

Contribuci贸n creada por: Mart铆n 脕lvarez (Platzi Contributor) con el aporte de Franco Daniel Carrara.

Aportes 25

Preguntas 5

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

Otra forma de ver al tipo de dato never es como aquellas funciones que nunca llegan a ejecutarse por completo

Never Type

El tipo de dato never, m谩s que todo sirve para tipar a una funci贸n que nunca va a finalizar o sencillamente que pueda terminar el programa en el caso de lanar una excepci贸n.

Un ejemplo de ello es cuando queremos manejar un error o cuando ejecutamos un loop infinito, como por ejemplo una validaci贸n de un token de cada x鈥檚 segundos, que es una funci贸n que se ejecuta constantemente, ya que lanzas la funci贸n, esta env铆a el token lo valida, y comienza el timer para hacer el refresh de ese token, si hay un error lanza una excepci贸n y si no contin煤a con la validaci贸n y el timer鈥

// esta funcion no tiene un punto final ya que dispara una excepcion
function error(mensaje: string): never {
    throw new Error(mensaje);
}

// esta funcion no tiene un punto final ya que dispara un error
function fallo(): never {
    return error("Reportar fallo");
}

// esta funcion no finaliza ya que posee un loop infinito
function loopInfinito() : never {
    while(true){}
}```

Si bien esta bueno en caso de funciones donde este tipo de finalizaci贸n de programas es clara (Como en un while true o el throw), no siempre detecta las funciones que son never.

Estos casos los infiere de tipo void aunque su ejecuci贸n sea infinita y detengan la ejecuci贸n del resto del programa.

Infiere void:

const badFor = () => {
  for(let i = 1; i < 10; i){
    console.log(i)
  }
}

Infiere void:
const badRecursion = () => {
if(true){
console.log(鈥極h sh*t here we go again鈥)
badRecursion()
}
}

Si bien TS puede inferir algunas funciones infinitas y que detengan la ejecuci贸n no lo har谩 siempre, por lo que tenemos que seguir haciendo testing 馃槂

Por lo que vi, never no es un type que debas declarar como tal.

Es m谩s la inferencia que typescript hace a tu c贸digo y determina que ese proceso nunca va a terminar, bien sea un ciclo infinito o un error que detiene el programa.

Encontr茅 hace poco otro caso d贸nde aparece el never, en las propiedades de una clase que se inicialzan con un array vac铆o y no se les define el tipo, as铆:

class Algo {
  miVariable = []; // (property) Algo.miVariable: never[]
}
withoutEnd()

HEROES NEVER TYPE!!!

El uso mas com煤n de never es cuando por alguna rara razon, necesitamos usar en nuestro codigo un tipado condicional. (conditional-types) ejemplo:

// declaramos un tipo perro
type Dog = {barks : true};
// queremos evaluar un generico que probablemente use union 
// de tipos donde se incluya otros animales
type Animals = Dog | Cat | Wolf;
// Creamos un tipo condicional porque algunos casos
// necesitamos exclusivamente el tipo Dog
type ExtractDogish<A> = A extends { barks: true } ? A : never;
const dog : ExtractDogish<Animals> // Dog 
const cat: ExtractDogish<Animals> // never

Si necesitas crear una funcion infinita, usa este tipo de dato never.

El tipo 鈥渘ever鈥 en TypeScript representa el tipo de valor que nunca ocurre. Esto significa que una funci贸n que nunca retorna o que siempre lanza una excepci贸n tiene un tipo de retorno 鈥渘ever鈥. El tipo 鈥渘ever鈥 tambi茅n se utiliza para anotar variables que nunca pueden tener un valor v谩lido.
.
Aqu铆 tienes un ejemplo pr谩ctico de c贸mo se utiliza el tipo 鈥渘ever鈥 en TypeScript:

// Funci贸n que lanza una excepci贸n
function throwError(message: string): never {
  throw new Error(message);
}

// Funci贸n que nunca retorna
function infiniteLoop(): never {
  while (true) {
    console.log("Este bucle es infinito.");
  }
}

// Variable que nunca puede tener un valor v谩lido
let unreachableValue: never;

// Llamada a la funci贸n que lanza una excepci贸n
throwError("Se produjo un error.");

// Llamada a la funci贸n que nunca retorna
infiniteLoop();

// Asignaci贸n de un valor a una variable de tipo "never" (esto dar谩 error)
unreachableValue = 10;  // Generar谩 un error: Type '10' is not assignable to type 'never'

En el ejemplo anterior, tenemos una funci贸n llamada throwError que lanza una excepci贸n utilizando la palabra clave throw. Esta funci贸n tiene un tipo de retorno 鈥渘ever鈥 porque nunca retorna un valor normal.
.
Tambi茅n tenemos una funci贸n llamada infiniteLoop que contiene un bucle infinito utilizando la condici贸n true. Esta funci贸n tambi茅n tiene un tipo de retorno 鈥渘ever鈥 porque nunca sale del bucle y nunca retorna un valor.
.
Adem谩s, declaramos una variable unreachableValue con el tipo 鈥渘ever鈥, lo que significa que esta variable nunca puede tener un valor v谩lido asignado.
.
Al llamar a la funci贸n throwError y infiniteLoop, estamos utilizando funciones que tienen un tipo de retorno 鈥渘ever鈥.
.
Sin embargo, si intentamos asignar un valor a la variable unreachableValue, como se muestra en el ejemplo, se generar谩 un error porque el tipo 鈥渘ever鈥 no puede tener ning煤n valor v谩lido asignado.
.
El tipo 鈥渘ever鈥 es 煤til para indicar situaciones en las que se espera que una funci贸n nunca retorne o para anotar variables que nunca pueden tener un valor v谩lido.
.
Espero que este ejemplo pr谩ctico te haya ayudado a entender el tipo 鈥渘ever鈥 en TypeScript. Si tienes alguna otra pregunta, 隆no dudes en preguntar!

Pienso que la parte inicial no es clara . Simplemente es para definir algo que no va a ocurrir, en lo que habla al inicio es cimplemente que nunca va tirar un valor de return y en el caso de error es lo mismo nunca va retornar por que siempre ejecuta un error

function throwError(errorMsg: string): never { 
            throw new Error(errorMsg); 
} 
Mis apuntes: ```js const withoutEnd = () => { while (true) { console.log('nunca para de aprender'); } }; const fail = (message: string) => { throw new Error(message); }; const example = (input: unknown) => { if (typeof input === 'string') { return 'es un string'; } else if (Array.isArray(input)) { return 'es un array'; } return fail('not match'); }; console.log(example('Hola')); console.log(example([1, 2, 3, 1])); console.log(example(1234)); //se detiene ```const withoutEnd = () => { while (true) { console.log('nunca para de aprender'); }}; const fail = (message: string) => { throw new Error(message);}; const example = (input: unknown) => { if (typeof input === 'string') { return 'es un string'; } else if (Array.isArray(input)) { return 'es un array'; } return fail('not match');}; console.log(example('Hola'));console.log(example(\[1, 2, 3, 1]));console.log(example(1234)); //se detiene
Otro uso que he visto, es en funciones al momento de retornar algo. Con never no se puede retornar algo, al contrario de void que si como algo vac铆o
**never** funciones que lanzan errores o entran en bucles infinitos.

Detectar un array

Never Type

Tambi茅n puede servir para las funciones que se encargan del monitoreo de cierta informaci贸n cada cierto tiempo, como por ejemplo un servicio de OneDrive que cada 5 minutos pregunta a la 鈥渘ube鈥 si hay algunos archivos nuevos que el usuario actual no tenga en un directorio sincronizado.

Si bien el proceso de revisar termina, el proceso del monitoreo es continuo y sin fin.

No me convenci贸, nunca llam贸 a la funci贸n: withoutEnd, ni tampoco al tipo de dato never.

Entiendo el tipo never en las funciones como aquellas funciones que nunca retornan al flujo de su llamado.

Por ej. si ejecutas la funci贸n withoutEnd, nunca retornar谩, porque es un ciclo infinito. Imprimir谩 por siempre nunca pares de aprender.

Al ejecutarse la funci贸n example en la linea 24, esta a su vez llamar谩 a la funci贸n fail, la cual lanza un error y por tanto nunca retorna, y es por ello que no se ejecuta la linea 25

La diferencia con el return void, es que estas funciones aunque no retornen un valor como tal, el flujo si retorna a su llamado normalmente, de hecho puedes colocar un return. En el sig ejemplo la funci贸n se ejecuta, imprime Hi, retorna al flujo y luego imprime Hello.

const _print = (message: string) : void => {

    console.log(message)

    return
}

_print('Hi')

console.log("Hello")

Notas de clase:


// esta funcion no finaliza ya que posee un loop infinito
  const withoutEnd=()=>{
    while (true) {
      console.log('Nunca pares de aprender');
    }
  }
// esta funcion no tiene un punto final ya que dispara una excepcion
const fail = (message:string)=>{
  throw new Error(message);
}

const example = (input:unknown)=>{
  if (typeof input === 'string') {
    return 'Esto es un string';
  }else if(Array.isArray(input)){
    return 'Esto es un array';
  }
  return fail('not match');
}

console.log(example('Hola'));
console.log(example([1,2,3,4]));
console.log(example(123)); // se detiene
console.log(example('Hola despues del fail'));
endless()

Tengo una inquietud! me sale este error al momento de ejecutar el programa,
"\ts-app\dist\04-never.js:8
throw new Error(message);
^

Error: not match
at fail (D:\Users\User\Documents\cursoTypeScript\ts-app\dist\04-never.js:8:11)"

Pero en el c贸digo no me arroja ningun inconveniente! 驴Alguien tiene idea de que estoy haciendo mal?

este es mi c贸digo;
const fail = (message: string)=>{
throw new Error(message);
}
const example=(input: unknown)=> {
if (typeof input === 鈥榮tring鈥) {
return 鈥榚s un string鈥;
} else if (Array.isArray(input)) {
return 鈥楨s un array鈥;
}
return fail(鈥榥ot match鈥);

}
console.log(example(鈥楬ola鈥));
console.log(example([1,2,3]));
console.log(example(12));
console.log(example(鈥楬ola despues del fail鈥));



const withoutEnd = () => {
  while (true) {
    console.log('nunca para de aprender');
  }
}

const fail = (message: string) => {
  throw new Error(message);
}

const example = (input: unknown) => {
  if (typeof input === 'string') {
    return 'es un string';
  } else if (Array.isArray(input)) {
    return 'es un array';
  }
  return fail('not match');
}


console.log(example('Hola'));
console.log(example([1,1,1,1]));
console.log(example(1212)); // detiene
console.log(example('Hola despues del fail'));
console.log(example('Hola despues del fail'));
console.log(example('Hola despues del fail'));

Never type sirve para detener de forma forzada la ejecuci贸n de alg煤n programa. Esto lo podemos definir mediante una funci贸n que retorna un throw error o simplemente definiendo el type never.

y ese doble 01 nunca se cambio鈥 jaja es broma gran curso hasta el momento!