Resumen

Como dato extra, cuando una función recibe otra función, el tipo de esa función se define de esta forma.

function apply(items: number[], fn:(item: number) => number): number{
    ///....
}

El valor de retorno se define con =>

Me parece que hace falta un curso practico con TypeScript, si bien aqui los ejemplos son practicos, no dejan de ser simplemente eso, ejemplos de los fundamentos, esta bien explicado pero estos ejemplos los puedo encontrar en internet facilmente, seria mejor que cada tema que veamos, sea aplicandolo a un proyecto real que vayamos contruyendo.

Resumen
Usar never cuando vamos a lanzar excepciones en la función.
Al momento de usar la función, ponerlo en un try catch.

null y undefined son subtipos de void. A su vez, null y undefined son subtipos de :

• number
• boolean
• string
• array
• tuple
• enum
• any
• void
• object

Para capturar el error y, por ejemplo, mostrarlo en la terminal sin que el programa termine, podemos agregarle una linea al catch:

try {
  let result = handleError(200, 'OK');
  console.log(`result: ${result}`);
  result = handleError(404, 'error');
  console.log(`result: ${result}`);
} catch (error) {
  console.log(`${error}`);
}

Excelente Hasta el momento!

// Tipo de retorno con TypeScript
function handleError(code: number, message: string): never | string {
    // Procesamiento del codigo, mensaje
    if (message === 'error') {
        throw new Error (`${message}. Code error: ${code}`);
    } else {
        return 'An error has ocurred';
    }
}

try {
    let result = handleError(200, 'OK'); // string
    console.log('result', result);
    result = handleError(404, 'error'); // never
    console.log('result', result);
} catch (error) { }

//Tipo de retorno en TypeScript

function handleError(code: number, message: string): never | string {
  // Procesamineto
  if (message === 'error') {
    throw new Error(`${message}. Code error: ${code}`);
  } else {
    return 'An error has ocurred';
  }
}

let result = handleError(200, 'OK'); // Devuelve un string
console.log('result', result);

try {
  result = handleError(404, 'error'); // Devuelve un error que debemos capturar.
  console.log('result', result);
} catch (error) {
  console.log('Se produjo un error y lo capturamos');
}

Un curso super claro y corto! muy bien

intersante clase

Vamos aprender las interfaces en ts

Gestion de valores de retorno en TS

null y undefined son subtipos de void

Tipo de retorno

//* Tipo de retorno
function handleError(code:number):never | string {
  //*Procesamiento del código, mensaje
  if (code === 404) {
    throw new Error(`Code error: ${code}: NOT FOUND`);
  }else if(code >= 200 || code <= 299){
    return 'Everything is perfect :)'
  }
  else {
    return 'An error has ocurred!'
  }
}

try {
  let result = handleError(200)
  console.log('result', result)
  result = handleError(404) //!Mostrará un error en la consola, es intencional
  console.log('result again: ', result)
} catch (error) {
  console.log('Oh no, han error ocurred:', error)
}

Recordar que type sirve para darle nombre a una expresión.

type Operacion = (n1: number, n2: number) => number

Funciones
Parámetros/argumentos son tipados y opcionales.El retorno puede ser una combinación de tipos. En Ts hay parámetros opcionales con ?. undefinded, cuando una variable no tiene un valor.
Flat array functión, function comprenhension.
Qué espero recibir de respuesta.
Tipado en el retorno.
El tipado de datos en TS es muy importante.

null y undefined son SUBTIPOS de VOID.

null y undefined son ESTADOS VÁLIDOS para las primitivas, arrays, tuplas, enums, etc…

Esto fue lo que quiso decir?

el tipo never lo deja claro: usarlo cuando gestiones errores o lanzar excepciones.

h

MY NOTES OF THE CLASS 😄

Aprendimos tipado de datos

Null y undefined se consideran subtipos de void

También que null y undefined son subtipos para el resto de tipos de datos que hemos estudiado

// Tipo de retorno con typescript

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

  //Procesamiento del mensaje

  if(message === "error"){

    throw new Error(`${message}. code error: ${code}`);
  }else{

    return 'un error ha ocurrido';
  }

}

try{
let result = handleError(200, "ok");//string
console.log('result',result);

result = handleError(404, 'error');//never
console.log('result', result);
} catch (error){

  
}

//Para poder arreglar el contexto donde ejecutamos nuestra funcion
  //Utilizamos try catch y manejaremos el error dentro del mismo

/// CASES OF USE
function handleErrors(code: number, message: string): never | string {
    if(message === 'error') {
        throw new Error(`${message} - Code error: ${code}`);
    } else {
        return 'An error has occur.';
    }
}

// for solutions
try {
    let result = handleErrors(200, 'OK'); // return String
    console.log('result 1 -> ', result);
    result = handleErrors(404, 'error') // return Never
    console.log('result 2 -> ', result);
} catch (error) { }