Never type

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’s 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(‘Oh 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 😃

withoutEnd()

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[]
}

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.

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.

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 === ‘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]));
console.log(example(12));
console.log(example(‘Hola 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!