No tienes acceso a esta clase

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

Errores (try / catch)

14/31
Recursos

Aportes 69

Preguntas 14

Ordenar por:

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

o inicia sesi贸n.

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.

<h3>Try/Catch</h3>

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 鈥渃olumna鈥 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鈥痬in 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.

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 鈥榣anzan鈥 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 鈥榗atch鈥 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.

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(鈥渕ensaje 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.
[ 鈥榮tack鈥, 鈥榤essage鈥 ]

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

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 鈥淢谩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

maravilloso capitulo

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');