Errores (try / catch)

Con Node podemos manejar los errores de una manera muy optima, pero primero debemos entender como Node maneja los errores por defecto.
Cuando sucede un error en Node, él por defecto terminara todo el proceso de nuestro código para avisar que ha ocurrido un error, esto puede ser fatal para nuestros proyectos, los errores además se notifican por hilos, es decir, que si un error sucede en el hilo principal del event loop, es decir, el evento queue, el error se avisara desde este mismo hilo, pero si un error sucede antes desde otro hilo como el hilo de las funciones asíncronas, el error se avisara desde aquel hilo sin dejar mostrar el error del hilo principal.
Nosotros podemos manejar este flujo de errores para que Node no se detenga al momento de que ocurra uno y lo podamos manejar según nuestros deseos, para esto usamos try y catch. Siendo try el bloque de código que ejecutara la función que puede o no fallar y siendo catch la función que atrapara el error y le especificaremos que hacer con él.

Errores (Try/Catch)

Cuando se genera un error, node propaga el error hacia arriba, hasta que esta es caputado. si el error no se captura node se detiene.

Siempre que sea posible debemos capturar todos los errores que se puedan generar en nuestros hilos.

Non permite caputar los errores:

const badfunction = () => 5 + z;
try {
    badfunction()
} catch (error) {
    console.log('bad function ha fallado')
    console.error(error.message)
}
console.log('continuamos...')

Si deseamos manejar errores asincronos:

function badfunction() {
    setImmediate(() => {
        try {
            return 5 + z
        } catch (error) {
            console.log('bad function ha fallado')
            console.error(error.message)
            console.log('continuamos...')
        }
    });
}
badfunction()

En caso que te de curiosidad como a mi, porque el error dice :

errores.js:2:5
<code>

El primer numero (2) es la linea y el segundo número (5) es la “columna” cada columna puede ser un caracter o un espacio.

En este caso, dice que el error esta (min 6:43) en linea 2 columna 4 que es donde efectivamente se esta llamando la función

<code>
serompe()

Buena clase. Me llama la atención que si no puedo capturar errores de otro hilo, pensaría que lo que falle en aquel hilo no debiese afectar el event loop principal. Pero sí lo hace. Así que hay que estar atentos de catchear muy bien los errores en todo momento.

Errores (try / catch)

El Try/catch nos sirve para saber si hay un error o no, y poder modificar el output del error.

try {
    seRompe()
} catch (error) {
    console.error('Vaya, algo se ha roto...')
    console.error(error.message)
}

La App se a crashed cuando hemos intentado con una función Async.

function seRompeAsync() {
    setTimeout(() => 3 + z)
}

try {
    seRompeAsync()
} catch (error) {
    console.error('Vaya, algo se ha roto...')
    console.error(error.message)
}

Para que esto no pase, tenemos que hacer el Try/catch adentro de función.

function seRompeAsync(cb) {
    setTimeout(() => {
        try {
            return 3 + z
        } catch (error) {
            cb(error);
        }
    })
}

try {
    seRompeAsync((error) => console.error(error.message))
} catch (error) {
    console.error('Vaya, algo se ha roto...')
    console.error(error.message)
}

Esto me recuerda a las excepciones con Java. Sin embargo, aqui no es necesario que los métodos lleven el throw Exception que avisa a los demás métodos de sus excepciones.

Me estoy pasando todo el curso en 1.25x o 1.5x :v
Habla muy lento y son videos de 10 min la mayoría

Pero explica muy bien y son cosas muy útiles

• El manejo de errores se hace con el módulo try{} catch(err){}
• Debemos tener cuidad al tratar los errores en acciones asíncronas, y en el hilo principal, pues las funciones asíncronas son enviadas a un hilo diferente al principal.

• try {...} catch (err) {...} usamos try catch para capturar los errores. Las capturas se pueden dar en funciones anidadas, sin embargo en una función asíncrona, el try catch debe estar en dicha función, para poder capturar el error.

Código:

Try/Catch

Se usa para la ejecución de código y captura de errores de esa ejecución. Nos ayuda a tener un control de errores en nuestro código.

Debemos entender que node al detectar un error rompe totalmente la ejecución del hilo para evitar daños mayores, es por esto que con try/catch podemos capturarlo y desplegarlo en la consola o darle un manejo mas eficiente.

Código síncrono

function seRompera() {
  return console.log(3 + x); 
}

function otraFuncion() {
  return seRompera();
}

try {
  otraFuncion();  
} catch (error) {
    console.error('Lo siento algo fallo');
    console.error(error.message);
}

console.log('Otra instrucción');

Para el código asíncrono debemos considerar que al entrar al event loop este cambia de hilo, pues enviado al event queue que lo envía al thread pool donde es procesado en un hilo independiente, es allí donde el error es detectado y enviado al event loop donde se corta toda la ejecución del programa.

function seRompeAsincrono() {
  setTimeout(()=> {
       console.log(3 + x)
  }, 1000)
}

try {
  seRompeAsincrono();  
} catch (error) {
    console.error('Lo siento algo fallo');
    console.error(error.message);
}

console.log('Otra instrucción');

//Fallara

el try/catch debe ir dentro del código asíncrono y cuando exista este cambio de hilo de ejecución, se pueda capturar el error presentado.

function seRompeAsincrono() {
  setTimeout(()=> {
     try {
       console.log(3 + x)
     } catch (error) {
      console.error('Lo siento algo fallo');
      console.error(error.message);
     }
  }, 1000)
}

try {
  seRompeAsincrono();  
} catch (error) {
    console.error('Lo siento algo fallo');
    console.error(error.message);
}

console.log('Otra instrucción');

muy importante la interpretaciòn de los errores, en espcial para identificar las lineas en donde se esta rompiendo el codigo.

function otraFuncion() {
     serompe();
}

function serompe() {
    return 3 + z;
}

try {
    otraFuncion();
} catch(err) {
    console.error('error en el llamado');
    console.error(err.message);
    console.error(err);
}

console.log('despues de romper');

Nota importante sobre el correcto manejo de errores en Javascript. Existen funciones que no ‘lanzan’ explícitamente los errores, sino que los manejan dentro de sus propios parámetros de llamada, y es ahí en donde nosotros como buenos programadores debemos canalizarlos al ‘catch’ correspondiente, lanzándolos de forma explícita para que el error se maneje de la mejor forma posible. Veamos el siguiente ejemplo utilizando las funciones de lectura y escritura del filesystem:

const filesystem = require('fs');

function leerArchivo(archivo, callback) {
    filesystem.readFile(archivo, function (error, data) {
        try {
            if (error) throw new Error(error); // Lanza explícitamente el error, incluso podemos personalizar el error y colocarle el mensaje que nosotros necesitemos.
            callback(data); // Si lanza error nunca ejecuta el callback
        } catch (error) {
            console.error(error.message);
        }
    });
};

// Prueba colocando un archivo no existente para que logres observar como manejamos el error desde el mismo callback de la funcion readFile del filesystem
leerArchivo('archivo.txt', function (data) {
    console.info(data.toString()); // Si ocurre error esto jamás se ejecuta, así nos evitamos recibir el error hasta acá para evaluarlo con una condicionante.
});

Espero les sirva este aporte. Happy Coding!

Un error en Node rompe totalmente la ejecución del código.

En la primera línea del documento escriban el siguiente código.

console.clear();

Les limpiará consola para seguir viendo el último log 😎

Para capturar errores , yo acostumbro instanciar la clase new Error(“mensaje personalizado”);

Algo muy importante que sera importante para las futuras tramas… Es el uso de los objetos y sus propiedades,

Hay propiedades ocultas que podemos manejar, un ejemplo es el objeto de ERRORES en los catch.

Con:
console.log(Object.getOwnPropertyNames(error))

Podemos ver que tiene 2 propiedades que desconcemos.
[ ‘stack’, ‘message’ ]

Esto lo podemos ver y usar a nuestro favor…

Saludos!

Cuando una funcion lanza un error que esta dentro de otra funcion, el error se lanza hacia arriba como en una burbuja

function otraFuncion() {
    seRompeAsincrona((err) => {
        console.log(err.message)
    });
}


function seRompe() {
    return 3 + z;
}

function seRompeAsincrona(cb) {
    setTimeout(() => {
       try { 
        return 3 + z;
       } catch(err) {
        console.error('Error en mi funcion asincrona');
        cb(err);
       }
    })
}


try {
    otraFuncion();
} catch(err) {
    console.error('Vaya algo se ha roto...');
    console.error(err);
    console.log('Pero no pasa nada, lo hemos capturado')
}

console.log("Con try catch el programa no se rompe del todo muestra el error y sigue corriendo las demas lineas de codigo wow it's amazing");

Yo creo que no es necesario tener el try catch dentro del hilo principal porque nos protegemos del error en la llamada asincrona

function seRompeAsincrona(cb){
    setTimeout(() => {
        try{
            return 3 + z
        }catch(error){
            console.error('Error se rompe Asincrona')
            cb(error)
        }
    },1000)
}


seRompeAsincrona(() => {
    console.log('Hay error')
})

setTimeout(()=>{
    console.log('Still alive')
},2000)


console.log('El final')

Este tipo de funcion nos permite encontrar errores dentro de Node.js pero seguir ejecutando el resto del código. Adicionalmente cuando se generan los errores nos permite continuar realizando operaciones sin afectar el resto del código.

Siempre que sea posible debemos capturar todos los errores que se puedan generar en nuestros hilos.

   function malaFuncion(x){
    	console.log('iniciamos la función');
    	return 5 + z;
    }
    malaFuncion(10);
    console.log('terminamos la función');
    /* 
    Esta función se rompería puesto que estamos pidiendo un Z y le estamos dando un X.
    por tanto la respuesta de la terminal sería:
    - iniciamos la función
    y luego se rompería y no nos enviaría la ultima consola
    */
    
    
    try {
    	malaFuncion(10);
    } catch (error) {
    	console.log('hubo un error en la función debido a: '+ error)
    }
    console.log('terminamos la función');
    /* 
    Con try/catch la respuesta de la terminal sería:
    - iniciamos la función
    - hubo un error en la función debido a ERROR (no se rompe; le damos una solución en caso de que la función falle).
    - terminamos la función
    */

maravilloso capitulo

Try catch : Maneja o control los errores en el momento de la ejecución del código.

function seRompeAsincrona(){
    return new Promise( (resolve, reject)  =>{ 
        setTimeout(() => {
            try {
                let resultado =  3 + z;
                resolve(resultado)
            } catch (error) {
                reject(error)  
            }
        }, 1000);
    })
}

seRompeAsincrona()
    .then(respuesta => console.log(respuesta))
    .catch((e) => console.log(e.message))

``
try
{
    // Sometemos a un bloque seguro a código que esperemos o supónemos
    // se puede romper en algo.
}
catch (objerr)
{
    // El bloque try se deja de ejecutar apartir de la linea en donde el 
    // error sucedió y nos redirije al catch, donde capturamos y procedemos
    // a tratar un determinado error.
    console.error('Se ha roto algo'); // Texto simple o informativo
    // damos formato al objeto error el cual contiene información detallada
    // de que ha salido mal.
    console.error(objerr);
}
```

Usando sintax moderna quedaria asi:

const seRompe = () => 3 + z;

try {
  seRompe();
} catch (error) {
  console.error('Se ah roto:', error.message);
};

console.log('Sigue el programa');

try catch: sirve para capturar errores cuando el código a ha fallado, se puede indicar que hacer cuando se captura el error, o simplemente mostrarlos

14 Clases completadas de este curso y me gusto mucho este tema del manejo de errores es bien importante saberlos capturar y asi evitar que todo Node se detenga

Siempre me he acostumbrado por buenas prácticas(no silenciar errores) a capturar los errores específicos y no errores genéricos, tanto en python como en php, no sé si en node esto no sea una buena práctica. Ejemplo encontrado en https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Error:

function asyncBreakItself(callbackErrorFunc) {
  return setTimeout(() => {
    try {
      3 + z;
    } catch (e) {
      if (e instanceof ReferenceError) {
        callbackErrorFunc(e.message);
      }
    }
  });
}

¿Conocen alguna manera “Más limpia” de capturar errores específicos?

Cuando ocurre un error y usamos try/catch en la etapa de catch(error), error es un objeto el cual tiene 3 índices:

error. name > referencia del error
error. message > mensaje del error
error. stack > referencia del error en … __ filename etc etc

Yo lo hice con promesas pero solo me funciona cuando le pongo reject, cuando declaro una variable no existente no me lo respeta.

const asyncBreak = () =>{
    return new Promise((resolve, reject) => {
        setTimeout( () =>{
            reject('Error malo')
        },1000)
    })
}

const main = async ()=>{
    console.log('Lo pongo al inicio');    
    try{
        await asyncBreak()
    }catch(err){
        console.log(`Vaya, algo se ha roto :( por ${err}`);
    }
    console.log('Lo pongo al final');
}

main()

Hay que tener en cuenta en que hilo puede ocurrir un error, por ejemplo en donde se ejecutan las funciones asíncronas para desde ahí hacer algo con el error, ya que en nuestro hilo principal no podremos tratarlo apropiadamente.

/*
  Manejando errores,
  hay que estár pendiente de cuando algo puede generar
  error, para tomar accion en caso que suceda...

  Un error en Node, o Js generalmente bloquea el hilo principal
  e impide que otras funciones se ejecuten por eso la importancia
  de manejar errores. Se puede usar el bloque try catch

  Los errores en Node escalan, no hasta la funcion de donde provino, sino hasta
  la que fué llamada y que tiene lo que desencadenó el error.
*/

function otraFuncion(){
  seRompe();
}

function seRompe(){
  return 3 + z;
}

function seRompeAsincrona(fn){
  setTimeout(() => {
    try{
      return 3 + a;
    } catch(error){
      fn('Algo pasó');
      console.log('Error en mi funcion asincrona');
    }
  });
}

try{
  // otraFuncion();
  seRompeAsincrona(function(err){
    console.log(err);
  });
} catch(error){
  console.error('Algo ha sucedido', error.message);
}

console.log('Esto se ejecutará');```

Podemos manejar nuestros errores con try catch y dependiendo de si necesitamos saber que debemos ver esos errores, siempre teniendo en cuenta que el try-catch lee dependiendo el hilo y tenemos un hilo asíncrono y un hilo síncrono.
por lo mismo es mejor hacer un try catch en cada petición asíncrona dependiendo de la importancia que tiene el error para nosotros en cada caso.

function rotoasync(cb) {
  setTimeout(() => { 
    try{
      return 3 + z
    } catch(err){
      return cb(err)
    }
  })
}

// Try catch en funciones síncronas

function broke(){
    return 3 + z;

}

try{
    broke()
}
catch (err){
    console.error('Ojo que algo se rompió')
    console.error(err.message)

}

console.log('Sin el try and catch no podríamos llegar aquí')


// Try catch en funciones asíncronas


// async function broke(){
//         setTimeout( function(){
    
//             try{
//                 return z
//             }
//             catch(err){
//                 console.log(err.message)
//             }
//         }, 1000
//           )       
//     }    

// async function main(){
//         await broke()
//         console.log('esta funcionando el await')
// }

// main()
// console.log('Lo que corre primero')

Ahora con la funcion asincrona.

function seRompeAsincrona(callback) {
    setTimeout(() => {
        try {
            return 3 + z;
        } catch (error) {
            console.error('error funcion asincrona')
            console.error(error.message);
            callback(error);
        }
        
    }, 1000);
}

try{
    seRompeAsincrona(() => {
        console.log('error')
    });
} catch(err) {
    console.error('error asincrona');
    console.error(err.message);
    console.error(err);
}

function otraFuncion() {
     serompe();
}

function serompe() {
    return 3+z;
}

function serompeASYNC(cb) {

    setTimeout(function () {
        try {
            return z+3;
        } catch (error) {
            console.log('error funcion asincrona');
            cb(error);
        }
    },1000);
}

try {
    // otraFuncion();
    serompeASYNC(function (error) {
        console.log(error.message);
    
    });
} catch (error) {
    console.error("No fu posible entrgegar respuesta")
    console.error(error.message);
    console.error(error);
}

Me da la impresión que el problema no quedó total mente resuelto. La linea 31, al final del vídeo, continuó sin ejecutarse producto del error lanzado por la función asíncrona 🤷🏻‍♂️. Si mal no lo entiendo, el event loop se detuvo. ¿Estoy equivocado? Gracias.

En el caso de la función asíncrona el try/catch del llamado ya no es necesario porque la función siempre va a retornar un resultado y siempre ejecutará el try.

El asincronismo con JS comienza a tomar forma en el backend, pero cuando lo vi estudiando fronted, no entendía para que demonios lo utilizaría !

Charcut en vscode : Si quieren crear una **carpeta **try y que **adentro **se cree un archivo catch.js lo hacen :

• Poniendo try"/"catch.js
  Voilà se crea una carpeta y adentro un archivo.js

Errores (try / catch)

try catch

El manejo de errores síncronos y asíncronos en JavaScript se realiza utilizando try...catch para errores síncronos y métodos como .catch() o bloques try...catch con async/await para errores asíncronos. Aquí te proporciono ejemplos de cómo manejar ambos tipos de errores:

Manejo de Errores Síncronos con try...catch:

try {
  // Código síncrono que puede arrojar un error
  const resultado = funcionSincrona(); // Supongamos que esta función lanza un error
  console.log(resultado); // Esta línea nunca se ejecutará
} catch (error) {
  // Manejo del error síncrono
  console.error('Se produjo un error síncrono:', error.message);
}

En este caso, el bloque try envuelve el código síncrono que podría arrojar un error. Si ocurre un error en ese bloque, se captura y se pasa al bloque catch. Puedes acceder al objeto error para obtener información sobre el error.

Manejo de Errores Asíncronos con async/await y try...catch:

async function doSomething() {
  try {
    // Código asíncrono que puede arrojar un error
    const resultado = await funcionAsincrona(); // Supongamos que esta función lanza un error
    console.log(resultado); // Esta línea nunca se ejecutará
  } catch (error) {
    // Manejo del error asíncrono
    console.error('Se produjo un error asíncrono:', error.message);
  }
}

doSomething();

En este caso, async/await permite que el código asíncrono sea manejado dentro de un bloque try...catch como si fuera síncrono. Si ocurre un error en la función asíncrona, se captura y se maneja en el bloque catch.

Manejo de Errores Asíncronos con Promesas y .catch():

someAsyncFunction()
  .then(result => {
    // Realiza alguna operación con el resultado
  })
  .catch(error => {
    console.error('Error en la promesa:', error);
  });

Cuando trabajas con promesas, puedes utilizar el método .catch() para manejar errores que ocurran en la ejecución de la promesa. Este método se encargará de atrapar cualquier error lanzado dentro de la promesa o en las promesas encadenadas.

El manejo de errores, ya sea síncronos o asíncronos, es fundamental para desarrollar aplicaciones robustas y detectar problemas en tiempo de ejecución. Debes elegir la estrategia adecuada según el tipo de operación que estés realizando.

Algo que pueden hacer es usar el try y catch en “seRompe” para evitar cualquier tipo de errores y luego llamar a la función de forma normal.
De esta forma aunque la llamen sola o dentro de otra función o con un setTimeout les va a funcionar como debe, no sé si sea lo más optimo pero para mi que recién empiezo es más cómodo.

    function serompe() {
    try{
        return 3+z
    }catch(e){
        console.error("Erro en tu código: "+ e)
    }
}

function serompe2() {
    setTimeout(()=>{
        serompe();
    }, 2000)
}

serompe2();

en lugar de z, para forzar un error, lo mejor es usar :

throw new Error()

Buenísima clase !!

Si tenemos sospechas que una función sincrona va a generar algún error en nodejs, lo recomendable es invocarla dentro de try{}, lo que hará que podamos capturar el error en catch(err){} en caso que haya alguno. Esto hará que nuestro proyecto no se rompa y siga con su ejecución, y el error se capture/notifique para fines de resolución, permitiendo así que el error no se propague por toda la red. No debemos olvidar que cuando tenemos algún error en nuestro proyecto, nodejs rompe la ejecución del mismo para evitar daños mayores.

Si la función es asíncrona, también debemos colocar la tarea de la función dentro del try{} y catch(err){}.

Les recomiendo la extensión de Error Lens y Turbo Console Log para estas cosas.

const otraFuncion = () => {
  seRompe()
}

const seRompe = () => {
  return 3 + z
}

const seRompeAsincrona = (cb) => {
  setTimeout(() => {
    try {
      return 3 + z
    } catch (error) {
      console.log("🚀 ~ file: errores.js:14 ~ setTimeout ~ error:", error.message)
      cb()
    }
  })
}

try {
  seRompeAsincrona(() => {
    console.error('hay error')
  })
} catch (error) {
  console.error("🚀 ~ file: errores.js:12 ~ error:", error.message)
}

console.log('aún funciona!')

Hola. diferencia entre declaracion let y var:

let te permite declarar variables limitando su alcance (scope) al bloque, declaración, o expresión donde se está usando. a diferencia de la palabra clave var la cual define una variable global o local en una función sin importar el ámbito del bloque.

Lo que permite hacer el try/catch es arrojar un error si hay algo que no opera bien dentro de mi función, evitando errores mas grandes o que se frene el proceso por completo.
Para las funciones asíncronas el try/catch debe ir dentro de la función, ya que, si se rompe algo al no estarse ejecutando en el hilo principal no nos avisará, a menos de que el try/catch esto dentro de dicha función asíncrona.

Volvi a este curso despues de haberlo visto hace un par de años. Ahora lo estoy haciendo con TS, y esta clase no se puede ejecutar porque TS no te permite compilar errores por mas que les hagas un trace del error.
Punto para TS

PD: les dejo una función para que guarden sus errores en un archivo

fs.appendFile(__dirname+'/errores.txt', error.message+'\n', (err: any)=>{
      if(err){
        console.log(err.message)
      } else {
        console.log('Se grabo correctamente el error')
      }
    })

Si desean agregar color a los mensajes en consola, deben agregar la sintaxis de ANSI color
Ejemplo:

 function seRompe() {
  return 3 + z;
}

try {
  seRompe();
}
catch (error) {
  console.warn('\x1b[33m%s\x1b[0m', 'Error de ejecución de la funcion' + '\x1b[34m seRompe() \x1b[0m');
  console.group('\x1b[41m%s\x1b[0m', 'Mensaje de Error:');
  console.error('\x1b[31m%s\x1b[0m', 'Error: ' + error.message);
  console.groupEnd('Mensaje de Error:');
}

// Colors reference
// Reset = "\x1b[0m";
// Bright = "\x1b[1m"
// Dim = "\x1b[2m"
// Underscore = "\x1b[4m"
// Blink = "\x1b[5m"
// Reverse = "\x1b[7m"
// Hidden = "\x1b[8m"

// FgBlack = "\x1b[30m"
// FgRed = "\x1b[31m"
// FgGreen = "\x1b[32m"
// FgYellow = "\x1b[33m"
// FgBlue = "\x1b[34m"
// FgMagenta = "\x1b[35m"
// FgCyan = "\x1b[36m"
// FgWhite = "\x1b[37m"

// BgBlack = "\x1b[40m"
// BgRed = "\x1b[41m"
// BgGreen = "\x1b[42m"
// BgYellow = "\x1b[43m"
// BgBlue = "\x1b[44m"
// BgMagenta = "\x1b[45m"
// BgCyan = "\x1b[46m"

https://nodejs.org/en/knowledge/errors/what-is-try-catch/

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/try...catch

// Errores Try/Catch

// La importancia de try and catch, se utiliza para funciones que posiblemente tengan errores, para no detener el proceso y ubicar el error.

function brokee(){
    return 3 + sdfg;
}

function itbroke(){
    broke();
}

function brokeA(cb){
    setTimeout(function (){
        try{
            return 3 + asdfas;
        }   catch(err){
            console.log('Oh, something was broken');
            cb(err);
        }
        
    })

}

//brokee();


//sincronico

//try se utiliza para probar la funcion, y si en algun comento se encuentra un error catch no comenta y ejecuta alguna linea.
// try{
//     itbroke();
// } catch(err){
//     console.log('Oh, something was broken');
// }

// Asincronico
brokeA( function(err) {
    console.log(err.message)
});

console.log('last mesaage');

function otraFuncion() {
    serompe();
}

function serompe() {
    return 3 + z;
}

function seRompeAsincrona(cb) {
    setTimeout(function() {
        try {
            return 3 + z;
        }catch (err) {
            console.error('error en mi funcion asincrona');
            cb(err);
        }
    })
}

try {
    //otraFuncion();
    seRompeAsincrona(function (err) {
        console.log(err.message);
    });
}catch(err) {
    console.error('vaya, algo se ha roto...');
    console.error(err.message);
    console.log('no pasa nada, lo hemos capturado');
}

console.log('esto de aqui está al final');

Yo aprendiendo la clase hice este codigo:

console.log("empecemos");
const uno = "Eres Trillonario";
const dos = "Eres PetaBillonario";
const tres_ = "Eres ArchiBillonario";
const cuatro = "Eres MegaArchiBillonario";
const cinco = "Eres HiperMegaArchiBillonario";
const seis = "Eres TopotoHiperMegaArchiBillonario";
const siete = "Eres AlfaTopotoHiperMegaArchiBillonario";
const ocho = "Eres OchoAlfaTopotoHiperMegaArchiBillonario";
const nueve = "Eres MetatronOchoAlfaTopotoHiperMegaArchiBillonario";
																	/* function splice(number) {
																		(output = []), (sNumber = number.toString());

																		for (var i = 0, len = sNumber.length; i < len; i += 1) {
																			output.push(+sNumber.charAt(i));
																		}
																		for (var i = 0, sum = 0; i < output.length; sum += output[i++]);
																		console.log(output);
																		uno_ = console.log("Salida1\t\t", sum);
																	} */

function spl(num) {
	let digits = num.toString().split("");
	let realDigits = digits.map(Number);
	console.log(realDigits);
	for (var i = 0, sum = 0; i < realDigits.length; sum += realDigits[i++]);
	console.log("Salida2\t\t\t", sum);
	dos_ = sum;
	tres(dos_);
}
function tres() {
	let dig = dos_.toString().split("");
	let realD = dig.map(Number);
	console.log(realD);
	for (var z = 0, suma = 0; z < realD.length; suma += realD[z++]);
	x = suma;
	console.log("Salida3\t\t\t\t", suma);
}

try {
	num = 28121962;
	spl(num);
	ether = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
	var a = x;
																			/* Comprobacion 3*/
																			/* switch (existeElementoa === a) {
																				case 3:
																					console.log("YES")
																				} */

	/* Comprobacion 1*/
																		/* let existeElementoUno = ether.find((a) => a == 1);
																		if (existeElementoUno === a) {
																			console.log(uno, a, a, a, a, uno);
																		} */
	/* FinalizaComprobacion 1*/
	switch (a) {
		case 1:
			console.log(a, uno);
			break;
		case 2:
			console.log(a, dos);
			break;
		case 3:
			console.log(a, tres_);
			break;
		case 4:
			console.log(a, cuatro);
			break;
		case 5:
			console.log(a, cinco);
			break;
		case 6:
			console.log(a, seis);
			break;
		case 7:
			console.log(a, siete);
			break;
		case 8:
			console.log(a, ocho);
			break;
		case 9:
			console.log(a, nueve);
			break;
		case 10:
			console.log(a - 9, uno);
			break;
		default:
			return a;
	}
	/* Comprobacion 2*/
																	/* let existeElementoDos = ether.find((a) => a == 2);
																	if (existeElementoDos === a) {
																		console.log(dos, a, a, a, a, dos);
																	} */
	/* FinalizaComprobacion 2*/

	/* Comprobacion 3*/
																/* let existeElementoTres = ether.find((a) => a == 3);
																if (existeElementoTres === a) {
																	console.log(tres_, a, a, a, a, tres_);
																} */
	/* FinalizaComprobacion 3*/

	/* 	if (ether.includes(a) === true) {
																						console.log(tres_, a, a, a, a,tres_);
																				}*/

	/* Comprobacion 4*/
																				/* let existeElementoCuatro = ether.find((a) => a == 4);
																				if (existeElementoCuatro === a) {
																					console.log("Si existe ", existeElementoCuatro, cuatro);
																				} */
	/* FinalizaComprobacion 4*/
	/* if (ether.includes(a) === true) {
																			console.log("si tiene", existeElementoCuatro, " entonces -", cuatro);
																			console.log("[|" + x + "|\44 " + x + " \44|" + x + "|]", x);
																		} else {
																			console.log("no");
																		}*/
} catch (err) {
	console.error("[|-|~\44~|-|]", "CapturadoError");
	console.error(err.message);
}

console.log("final");

Pregunta de examen:
Cuando se lanzan excepciones, ¿cómo las capturamos?

En esta clase no se puede pestañear , que informacion mas buena.

El try/catch se usa para manejar los errores que ocurren en la ejecución de nuestro código. Si sospechamos que un bloque de código generará un error es posible tratarlo con el uso de try/catch.
.
Para utilizarlo, simplemente ubicamos el bloque de código que queremos asegurar, y lo encapsulamos dentro de estás sentencias:

• try: En este bloque pondremos todo el código que consideremos que va a fallar.
• catch: Aquí estará el manejo de los errores que produjo el primer bloque. Si el código del try no genera estos errores, esta parte no se ejecuta.
• finally: Los bloques anteriores son de uso común, pero también existe otro que pudiera ser necesario en algún momento. Ya que este bloque finally se ejecuta siempre, no importa que el código haya producido un error o si en cambio todo marchó correctamente, este bloque nos ayuda a ejecutar sentencias después del proceso.

function otraFuncion()
{
  seRompe();
}

function seRompe()
{
  return 3 + z;
}

try
{
  otraFuncion();
} catch (err)
{
  console.error("Vaya, algo se ha roto");
  console.error(err.message);
  console.log("Pero no pasa nada");
} finally 
{
  console.log("El proceso a terminado");
}

Errores try / catch

En el proceso de desarrollar, una función puede lanzar un error debido a cualquier situación. Por lo tanto se debe utilizar el manejador de errores que proporciona JavaScript, este ayuda a controlar un error dado sin que la pila de ejecución se detenga y con ello detenga otros procesos que van a ejecutarse.

function breaks() {
	return 3 + z // z is not defined -> throw an error
}

breaks() // Error: z is not defined

Para manejar este error se puede hacer lo siguiente.

function breaks() {
	return 3 + z // z is not defined -> throw an error
}

try {
	breaks() // Este es el coódigo que va a intentar ejecutarse
} catch (error) {
	console.error(error.message) 
/* Catch agarra el error y con error.message obtiene 
el mensaje del error y lo envía a la consola. luego el código sigue su transcurso 
natural*/
}

Para las funciones asíncronas, se debe manejar el error de otra forma, debido a que las funciones asíncronas están en otra pila de ejecución y sus errores pasan desapercibido en el hilo principal.

function asyncBreaks(cb) {
  setTimeout(() => {
    try {
      return 3 + z
    } catch (err) {
      console.error('Error in my async function')
      cb(err)
    }
  })
}

asyncBreaks((err) => {
	console.error(err.message)
})

Errores (try / catch)

Cada vez que sepamos que una funcion puede romperse y puede disparar un error vamos a meterla en un try / catch.

Recordemos que un error en node para totalmente la ejecución de nuestro código.

Si hay una función asíncrona invocada dentro de la función envuelta en try catch, esta sale del hilo de ejecución principal y por eso debemos usar otro trycatch para ella

Tip: Cuando sabemos que algo puedo romperse, lo metemos dentro de un Try/catch. Esto hará que no se pare toda la ejecución del código.

Esta clase es muy buena! me ayudó a entender mucho mejor el manejo de errores. Primer curso con este profesor y ya se está ganando un lugar en mi lista de favoritos ⭐⭐⭐⭐⭐

This is my Code! 😃

Importate el manejo de errores, tal como lo mensiona el profe, para no parar la ejecuciòn del program.

si lo captura!!, yo digo que se propaga como en otros lenguajes

error.message

Tanto por aprender, sigamos.

try

Interesante que errores en el hilo de asincronía detenga lo que está pasando en el event loop principal

Tengo una pregunta básica.

 try {
    let  = 1 + z;
} catch (error) {
    console.error(error);
} 

¿ Por que el flujo se rompe si esta dentro de un try-catch ?

Definitivamente usar try catch es una de las mejores practicas a seguir si queremos un código profesional y menos dolores de cabeza en el futuro.

Genial que Node envie los errores al principio

Cuando se genera un error, node propaga el error hacia arriba, hasta que esta es caputado. si el error no se captura node se detiene.

Siempre que sea posible debemos capturar todos los errores que se puedan generar en nuestros hilos.

function otraFuncion() {
    seRompe();
}

function seRompe() {
    return 3 + z;
}

function seRompeAsincrona(cb) {
    setTimeout(function () {
        try {
            return 3 + z;
        }
        catch (err) {
            console.error('Error en mi funcion asincrona');
            cb(err);
        }
    })
}

try {
    //otraFuncion();
    seRompeAsincrona(function(err) {
        console.log('Hay error');
        console.log(err.message);
        
    });
}
catch (err) {
    console.error("Vaya, algo ha salido mal...");
    console.error(err.message);
    console.log('Pero no pasa nada, lo hemos capturado');
}

console.log('Esto de aqui esta al final');