Crea una cuenta o inicia sesión

¡Continúa aprendiendo sin ningún costo! Únete y comienza a potenciar tu carrera

Monohilo: implicaciones en diseño y seguridad

4/31
Recursos

Aportes 164

Preguntas 21

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Me encanta cuando les salen errores a los profesores. Refleja muy bien el flujo de trabajo real. Y aun que hay quienes critican a los profesores por esto, yo creo que es genial que no editen esas partes de la clase. Creo que a la gente que apenas inicia le va a servir mucho darse cuenta que el flujo de trabajo es de esa manera y les ayudará a evitar sentirse frustrados y con sindreome de impostor. Ademas, sin querer aprendes como puedes resolver esos problemitas, como en ete caso con el

console.log('forzamos error');

para asegurarse de que el bloque del if se ejecuta.

Importante: Cuando ocurre un error dentro de alguno de los hilos y no se controla apropiadamente (catch); Node detiene todos los hilos ejecución. Esto puede ser muy peligroso, debido a que es dificil determinar fue el origen del problema y en que punto de ejecución se encontraba cada hilo cuando fue detenido.

RESUMEN :


El hecho de que sea monohilo lo hace delicado en el sentido de que puede ejecutarse algo que corte el código y detenga el programa, como la ausencia de sintaxis o una variable pendiente por definir.

Aquí se pueden ver los problemas de seguridad y los Updates en este tema. Muy interesante leerlo para entender cómo atacan y saltan el código y cómo lo resolvieron.

A continuación dejo el código escrito con algunos comentarios de utilidad:

console.log('Hola mundo');

// SetInterval me permtie ejecutar una función cada n cantidad de tiempo, por lo que quiere que recibe como argumentos: Función a ejecutarse, intervalo de tiempo.
//A tener  en cuenta esta función no se detiene y continúa su ejecución ad infinitum.
// Detener ejecución con ctrl+ alt + m en Run Code, o con Ctrl +c en la terminal.
setInterval(function(){console.log('Voy a contar hasta infinito, detén mi ejecución o consumo tu memoria'),1000}); // Esta instrucción es asíncrona, por lo que se ejecuta en n momento.


let i = 0;
setInterval(function() {
    console.log(i);
    i++;

// Al ser monohilo el peligro recae en que si el código se ejectua y no tenemos cuidado el no asignar una variable de manera correcta me puede arrojar un error.
//Hay que escuchar los errores, es muy imporante de todo lo que pase en el código. Comprobar funciones y revisar lo que posiblmente puede fallar.
//Es clave estar pendiente de todos los errores que pueda cortar la ejecución, lo que se corta corta todo.
// Todo lo que sea asíncono y lo pueda llevar a ello, pues llevarlo, y todo lo que no, revisar que no corte el programa.

    // if (i === 5) {
    //     console.log('forzamos error');
    //     var a = 3 + z;
    // }
}, 1000);


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

MONOHILO

PROCESO DE NODE

    1.- Va a abrirse un proceso, ese proceso es un proceso de node
    2.- Interpreta todo el archivo
    3.- Convertirlo a código maquina
    4.- Prepara todo lo que necesita para ejecutarse
    5.- Se ejecuta
    6.- Se cierra el proceso, y termina

DESVENTAJAS MONOHILO

    - Si no se manejan bien los errores y uno truena, ya no continua con los procesos posteriores
    - Debes estar pendiente de todo el código

Segunda clase del curso, y aparte de los dos cursos que ya tome con Freedy, este maestro es el que siento yo, mejor explica y mejor da a entender las cosas 😄

Si, y si pones un timeout de 0 seguiría ejecutándose primero la “segundo instrucción”, porque hasta que no acabe el hilo principal no empiezan a ejecutarse las instrucciones que has enviado al event loop. Pero si explicara esto ya tendria que meterse a explicar otras cosas como las pilas de eventos etc

Les dejo mis notas hechas con Notion de la clase ^^

Es algo interesante cuando los profesores cometen errores, dan a entender que no estan copiando y pegando codigo de otra parte, si no que enseñan con sus propias lineas 😄

Si quieren evitar que un error les corte el programa pueden usar TRY CATCH de la siguiente manera:

let i = 0;
setInterval(function () {
    console.log(i++);
    try {
        if (i === 5) {
            var a = 3 + z;
        }
    } catch (error) {
        console.error(error)
    }
}, 1000)
var i = 0;
setTimeout( () => {
    console.log(i++);
},1000);

setTimeout solo se ejecuta en cierto tiempo a diferencia de SetInterval que se ejecuta cada cierto tiempo

Como aporte, quisiera aclarar que el setInterval no se ejecuta de último porque dure 1000ms, podemos ponerlo en 0 y va a seguirse empezando a imprimir de último.
La razón de que esto suceda es que el Event Loop no deja que nada asíncrono empiece siquiera a ejecutarse hasta que el CallStack, en donde están todos los procesos síncronos y “normales”, no se quede vacío.
Por eso, aunque le pongamos 0ms, el resultado va a ser el mismo si hay funciones o procesos síncronos a la espera. Desde una funcion super compleja hasta un simple console.log()

A todos nos ha pasado más de una vez que se nos olvida guardar y pensamos que fallo algo, para mí funciono el hecho de cambiar el shortcut de Save a teclas que fueran más cómodas. Para acceder a la lista de shotcuts donde pueden editar Ctrl + K + S.

Y a mi por qué me nombran? 😛

En Node la ejecución de eventos es asíncrona, por lo que retornara los resultados apenas pueda hacerlo en cada evento. Es muy importante saber que si uno de estos eventos fallan, todo va a detenerse, por lo que hay que comprobar rigurosamente nuestro código ante los fallos que puedan suceder.

“Ahhhh… es que no había guardado , muy bien Carlos” , la de veces que me ha pasado eso 😄, lo conseguí solucionar activando el AUTOSAVE en VSCODE, ¿es esto una mala práctica? ¿puede afectar al flujo de trabajo con git, github, gitlab?

El monohilo es como una cinta de producción en un fábrica de cajas, cada proceso es una caja bien hecha pero un error es una caja enorme… mal hecha. Cuando la caja va a salir para su venta atasca el mecanismo ya que es muy grande. Por lo que las cajas que vienen detrás nunca llegan a “salir” (procesarse en el caso del código).

con la cara que dice que este pendiente de mis programas !!! se nota que lo dice desde la experiencia. Gracias!

Me alegra saber que no soy el único al que se le olvida guardar y luego no sabe por qué el código no hace lo que se espera 😅

Leyendo los comentarios hablan mucho de try/catch. Yo personalmente no los conozco aun. Espero aprenderlos durante esta clase.

-setInterval: EventLoop abierto y escuchando todo el tiempo

-Lo malo del Monohilo es que si no tienes cuidado cuando se ejecute un error se para por completo el proceso

ctrl + C = Parar el proceso.

let i = 0;

function Increment (seconds) {
    setInterval(() => {
        if(i === 1) {
            console.log(`Pasó ${i} segundo`)
        } else {
            console.log(`Pasaron ${i} segundos`);
        }
        i ++;
    }, seconds);
}

Increment(1000);

Ley de Murphy: Todo lo que puede salir mal, saldrá mal.

Muy importante haberlo entendido como programadores

Monohilo: implicaciones en diseño y seguridad

<console.log("Hello world!!");

let i = 0;

setInterval(function() {
  console.log(i);
  i++;

  if (i === 5) {
    console.log("forzamos error");
    var a = 3 + z;
  }
}, 1000);
>

Importante: debes estar pendiente en todo lo que ocurre en tu código.

En Monohilo, se debe estar pendiente de todo lo que pasa para que no se detenga todo el proceso. Qué hacer? Desarrollo basado en pruebas?

La verdad estoy muy contento con el curso, que calidad tan buena tiene el profesor de explicar. La verdad se le entiende todo muy claro. Esperamos seguir aprendiendo.

Tremendo crack el profe, creo que este curso debería estar o o si ya lo esta al inicio del curso de desarrollador web, ya que te ayuda a entender muchísimo mejor lo que pasa en js

Me encanta como enseña este maestro, yo recomiendo repasar las clases del curso de asincronismo con JavaScript y el curso de JavaScript Engine (V8) y el Navegador

“Todo lo que pueda fallar, antes de que falle: compruébalo”!

//event loop

let count = 10;

//infinite loop con respuesta en 5 y respuesta en -5
setInterval(() => {
    let name = "platzi"
    let course = "curso de nodejs"
    console.log(count--)
    if(count === 5 || count === -5){
        console.log(`estoy aprendiendo en ${name} el ${course}`);
    }
}, 1000);```

Para parar un proceso, es realmente con la señal SIG_TERM que es el CTRL-C en la terminal o desde un monitor de procesos, como ps -fea, ver el PID y mandarle esa señal.

kill -15 $NODE_RUNNING_PROCESS

Para los que están viendo la clase y no saben como detener la ejecución del setinterval, este se hace con ctrl + c, y el profe lo dice al final del video 😛

Una manera de asegurarte de que estas pasando todo correctamente y no tendrás esos errores en tiempo de ejecución, seria combinar Node con Typescript

Monohilo: implicaciones en diseño y seguridad


Para ejecutar un archivo con Node.js, tenemos que escribir en la terminal:

node file.js

⚠ Los archivos node-js su extensión es .js

Lo malo de que Node.js sea monohilo, es que cuando tengas un error, Node va parar todo y dejar de ejecutarse.

Al ser monohilo, si se detecta un error detiene por completo la aplicación.

Como la mayoría de mis compañeros ya dijo, es interesante ver como los profesores reaccionan a los errores.

Es una lección de como debemos actuar, calmados y entender que sucede.

Ctr + S y estamos guardando o habilitar el autosave. Es buena practica aprender atajos del teclado y configurar otras funcionalidades solo presionando combinacion de teclas.

Con la función setInterval puedes ejecutar acciones cada cierto tiempo, se pasa como parámetro el tiempo (cada cuanto tiempo se ejecutará) en milisegundos:

let i=0;

setInterval(function (){
  console.log("Acción "+i);
  i++;
  
  
  if(i === 5) {
    console.log("Se aproxima un erro D:");
    //Error 
    var error = n + 12;
  }
}, 1000);

console.log('Segúnda instrucción');

Usamos está función para comprobar el comportamiento de hilos en Node.js

Muy Buena Clase .

Mi código de la clase.

//Primera linea que se escribe
console.log('hola mundo');

//como este proceso toma mas tiempo en ejecutar se delega
let i =0;
setInterval(function () {
    console.log(i);
    i++;

    if (i===5) {
        var a =3+z
    }
},1000)

//como el proceso anterior fue delegado se continua con la siguiente linea e codigo.
console.log("segunda intruccion");
console.log("Hola mundo");

let i = 0;

setInterval(function() {
    console.log(i);
    i++;

    if (i === 5) {
        var a = 3 + z;
    }

}, 1000);


console.log("Segunda instruccion");```

¿Por que no se ejecuta almenos una vez la funcion setInterval y luego el 2do log. Ejemplo:

Output:
Hola mundo
0
Segunda instruccion
1
2
3
4…
¿Por que pasa de una al segundo log?

Código de la clase:

console.log('HolaMundo!!');

let i = 0;
setInterval(function()
{
  console.log(i);
  i++;
  if(i === 5 ){
    var a = 3 + z; 
  }
  //console.log('corta una cabeza, salen dos!!');
},1000);

Ejecución:

node nombre.js

![](

hay que estar atentos a los errores que puedan cortar la ejecución

Al ser monohilo, si se detecta un error detiene por completo la aplicación.

Todo lo que pueda fallar antes de que falle hay que comprobarlo.

Node.js es monohilo: ¿Qué significa eso y por qué importa en diseño y seguridad?

  1. Monohilo significa una tarea a la vez:

    • Imagina que tienes una lista de cosas por hacer. Node.js, al ser monohilo, es como si solo pudieras hacer una tarea a la vez de esa lista.
    • En términos de diseño, esto influye en cómo estructuras tu código. Necesitas ser eficiente y rápido en cada tarea, ya que no puedes hacer varias cosas al mismo tiempo.
  2. Event Loop:

    • Node.js utiliza algo llamado “Event Loop” para manejar múltiples operaciones sin crear nuevos hilos. Piensa en ello como un asistente que revisa tu lista de tareas y las hace una por una, siempre atento a nuevas tareas que puedan surgir.
    • Esto afecta al diseño, ya que debes entender cómo funciona este ciclo de eventos y asegurarte de que tu código no bloquee el Event Loop innecesariamente.
  3. Ventajas de la simplicidad:

    • Al ser monohilo, Node.js es más simple de entender y trabajar en comparación con entornos multi-hilo. Esto es bueno para el diseño, ya que te permite enfocarte en la lógica de tu aplicación en lugar de preocuparte por la sincronización entre hilos.
    • Sin embargo, también significa que debes ser cuidadoso con tareas que tomen mucho tiempo, ya que podrían bloquear el Event Loop y hacer que tu aplicación sea menos receptiva.
  4. Seguridad y bloqueo de Event Loop:

    • En términos de seguridad, debes evitar operaciones que bloqueen el Event Loop por mucho tiempo. Si tu aplicación está ocupada haciendo una tarea que tarda mucho, podría afectar negativamente la capacidad de tu aplicación para responder a otras solicitudes, lo cual podría ser explotado por posibles atacantes.
    • También, al ser monohilo, si un error grave ocurre y no se maneja correctamente, puede detener toda la aplicación.

si ponemos un try catch en el if no nos romperá el programa, es la forma de capturar estos posibles errores que nos pueden romper el programa

<
console.log('Hello word');

let i = 0;

setInterval(function() {
    console.log(i)
    i++
    try {
        if(i ===5){
            var a = 3 + z;
        }
    } catch (error) {
        console.log('error en el if')
    }
    
},1000);
console.log('segunda instrucción');
> 

✋ Holii! Si alguno le pasó como a mí, que cuando intentó ejecutar en la terminal le apareció este mensaje: "node no se reconoce como un comando interno o externo"
Sigan estos pasos para solucionarlo 😃

  1. Ir a Este Equipo Propiedades.
  2. Haz clic en Configuración avanzada del sistema en la barra izquierda de la ventana.
  3. Ahora tienes la ventana Propiedades del sistema. Haga clic en la pestaña Opciones Avanzadas.
  4. A continuación, haz clic en el botón Variable de entorno …
    5.Ahora tiene una ventana de variable de entorno: desde la variable de usuario, seleccione «Path»
  5. Haga clic en Editar
  6. Ahora, en Valor de variable, agregue la ruta de acceso donde se instaló Node.js. ( C:\Archivos de programa\nodejs).
    8.Aceptar y Aplicar en las siguientes ventanas.
  7. El paso final es reiniciar su ordenador.
    Felicidades, ahora puedes usar los comandos npm.

Es interesante ver como el profesor utiliza

console.log("forzamos error")

para saber si su bloque if se está ejecutando.

Puedes diferenciar entre un programador con experiencia y uno sin experiencia, viendo la cantidad de console logs en su código.

El programador sin experiencia casi no lo usa y por lo tanto, al momento de debuggear, se rompe la cabeza y tarda horas en resolver un problema.

El programador con más experiencia suele utilizar más loggear y además sabe cuando y donde ponerlos, de manera que la consola no se sature visualmente y sepa exactamente en donde está el problema.

Esta es simple y sencillamente, una forma de conocer el comportamiento de tu código y es súper importante.

La forma “normal” o “común” de loggear es así

console.log("tu mensaje")

Sin embargo, el método log de console, puede aceptar más de un parámetro, lo que te permite loggear información con un mejor formato.

Por ejemplo, si tienes una variable “x” que cambia de valor mientras el código se está ejecutando, y tu quieres conocer el valor de esta variable en diferentes etapas, lo puedes hacer con

console.log(x)

y esto como resultado te va a dar algo como

5

Ok perfecto, pero, si estuvieras loggeando más elementos ¿Como sabrías cual de todos ellos es realmente “x”?
Una forma es la siguiente:

console.log("x es igual a: ", x)

lo cual como resultado te va a dar:

x es igual a: 5

De esta forma le estamos pasando más de un parámetro al método log, y así estás loggeando de una manera más descriptiva que te va a facilitar mucho las cosas en un futuro.

Otra forma es la siguiente:

console.log({x})

Si te das cuenta aquí estamos loggeando a “x” dentro de dos paréntesis de llave, lo cual genera un “objeto” con “x” como key y el valor de “x” como value. Por lo tanto el resultado será el siguiente:

{x: 5}

lo cual también es bastante descriptivo.

Espero que a alguien le haya servido este comentario y puedan de ahora en adelante debuggear mejor utilizando bien el método log

Pregunta de entrevista: ¿Qué pasa si pones el timeout en 0 en vez de 1000?
R: Igualmente imprime:

  • Hola Mundo
  • Segunda Instrucción
  • 0
  • 1
    etc.

Ya que el event loop intenta primero resolver los problemas más simples, como imprimir algo, declarar o modificar una variable, etc, y envía las tareas mas complejas al thread pool donde se resuelven apenas sea posible.

Te ganaste un fan Carlos! Me encanta la manera que tiene de explicar este profesor!!! Super entendible

¿Que sucede?
Se habre un proceso de node, interpreta el archivo a codigo maquina, para ejecutarse, se ejecuta, y muestra en la consola el hola mundo , luego se cierra el proceso.
Ahora puede aver un problema al ser monohila, que si no andas con cuidado suficiente cuando se ejecute un error, para por completo nuestro proceso, andar pendientes de lo que pasa

Muy valiosa la forma de solucionar o encontrar la falla con el console.log también me quedo con si algo puede salir mal, saldrá mal, Excelente clase

Traten a sus procesos como a una figura de porcelana

Todo lo que puede fallar compruebalo, eso es extremadamente cierto

Me encanta cuando los profes se equivocan pues el error es parte del aprendizaje y es muy probable que cometamos los mismo errores

Estar pendiente de todo lo que pasa en nuestro código, lo entiendo, no saldrá de mi mente jamás.

Ya me dio miedo Node.

El principal problema de ser Monohilo es que cuando ejecute un error eso va a parar por completo nuestro proceso.

todo lo que puede salir mal saldra mal jajaj 😃 sera mi nuevo mantra

Resumen de clase
El que todo se ejecute en un hilo es una ayuda y al mismo tiempo fuente de problema. Si no tenemos claro cómo funciona.

console.log('Hola mundo');

Cuando ejecutamos node, se abre un proceso, compila el archivo a código maquina, prepara lo necesario para ejecutarse y se ejecuta. Una vez dice hola mundo cierra el proceso.

console.log('Hola mundo');
setInterval(()=>{
    console.log('Sigo activo');
},1000);

En este caso node tendrá el eventloop abierto y estar escuchando en todo momento.

console.log('Hola mundo');
let i = 0;
setInterval(()=>{
    console.log(i);
    i++;
    if( i === 5) {
        console.log('forzando el error');
        var a = 3+z; //z no esta definido y el error no aparece al compilar
    }
},1000);

En este caso el error aparece y node deja de ejecutar totalmente. El problema de ser monohilo es que cuando aparezca un error para por completo el proceso.
Debemos estar pendientes de errores, escuchándolos, evitándolos.
Si sucede un error porque no has estado pendiente, será tedioso resolverlo.

console.log('Hola mundo');
let i = 0;
setInterval(()=>{
    console.log(i);
    i++;
},1000);
console.log('Adios mundo');

la línea adiós mundo se va ejecutar sin esperar al setinterval, esa es la magia del comportamiento asíncrono

que bien explica el profeee ostiaaa

La clave en todo lenguaje es aprender debuggear el códico

Monohilo: implicaciones en diseño y seguridad

console.log('Hola mundo')

let i = 0
setInterval(function () {
  console.log(i)
  i++

  /* if (i === 5) {
    var a = 3 + z
  } */
}, 1000)

console.log('Segunda instrucción')

Se debe tener un cuidado muy grande al ejecutar sin tener las precauciones necesarias como: asignar las variables de forma adecuada, utilizar una sintaxis correcta, debido a que Node para todo si no se tiene un manejador de errores establecido y esto puede ocasionar problemas.

<h3>Monohilo</h3>
console.log("Hola Mundo")
//
let i = 0
setInterval(function() {
	console.log(i)
	i++
	
	if(i===5) {
	var a = 3 + z
	}
	console.log("sigo activo")
}, 1000)

console.log("segunda instrucción")

Si no tienes pendientes de tus parámetros tu hilo principal puede detenerse

node no funciona en la terminal.

Hola, acá les comparto un foro en Stack Overflow por si no les funciona el comando “node” en la terminal 😃

https://es.stackoverflow.com/questions/136407/node-no-se-reconoce-como-un-comando-interno-o-externo-programa-o-archivo-por

//Monohilo: implicaciones en diseño y seguridad

/*PROCESO DE NODE

    1.- Va a abrirse un proceso, ese proceso es un proceso de node
    2.- Interpreta todo el archivo
    3.- Convertirlo a código maquina
    4.- Prepara todo lo que necesita para ejecutarse
    5.- Se ejecuta
    6.- Se cierra el proceso, y termina

DESVENTAJAS MONOHILO

    - Si no se manejan bien los errores y uno truena, ya no continua con los procesos posteriores
    - Debes estar pendiente de todo el código
    El hecho de que sea monohilo lo hace delicado en el sentido de que puede ejecutarse algo que corte el código y
    detenga el programa, como la ausencia de sintaxis o una variable pendiente por definir
*/

console.log('Hola mundo');

let i = 0;

setInterval(function() {
    console.log(i);
    i++;

    // if (i === 5) {
    //     console.log('forzamos error');
    //     var a = 3 + z;
    // }
}, 1000);

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

Si les sale por defecto powershell en su consola de VS code para ponerle el bash (que por cierto les servirá mucho en este y varios cursos) solo tienen que seguir lo siguiente

  1. Instala Git from https://git-scm.com/download/win (Si ya lo tienes instalado pasa al paso 4)

  2. Abre VS code y presiona Ctrl + ` para abrir el terminal.

  3. Se mostrará en la parte inferior tu consola

  4. Abre el comando usando Ctrl + Shift + P.

  5. Escribe -> Select Default Shell

  6. Selecciona Git Bash

  7. Click en el ícono + en ventana del terminal

El nuevo terminal será un Git Bash terminal.

Monohilo: implicaciones en diseño y seguridad

Node al ejecutar o procesar código en un solo hilo es una ventaja y una fuente de problemas.

Buenas practicas

cuando estamos en la consola y ejecutamos un archivos js con node como por ejemplo node ejemplo.js primero se abrirá un nuevo proceso y es un proceso de node que va interpretar el archivo, lo convierte a código maquina, prepara todo lo necesario para ejecutar el código, luego se va ejecutar, muestra en pantalla el resultado y por ultimo el proceso se cerrara ocasionando que node termine.

Existe la opción de ejecutar algo que este siempre activo y lo podremos lograr de la siguiente manera:

setInterval(() => {
  console.log("Estoy activo"), 1000;
});

// 0
// 1
// 2
// 3
// 4...

En el código anterior le estamos diciendo a node que cada un segundo muestre en consola el texto ‘Estoy activo’, esto se ejecutara infinitamente. Pero si llegara a fallará algo, inmediatamente mostrara el error y node va para todos los procesos.

let contadorDeNumeros = 0;

setInterval(() => {
  console.log(contadorDeNumeros);
  
  if(contadorDeNumeros === 5) {
    console.log(contadorDeNumeros + numeroNoexistente);
  }
  contadorDeNumeros+=1;
}, 1000);

console.log(contadorDeNumeros);

// 0
// 1
// 2
// 3
// 4
// 5
// /home/mooenz/mis-apuntes/Curso-de-Fundamentos-de-Node-js/tempCodeRunnerFile.js:7
//     console.log(contadorDeNumeros + numeroNoexistente);
//                                     ^

// ReferenceError: numeroNoexistente is not defined
//     at Timeout._onTimeout (/home/mooenz/mis-apuntes/Curso-de-Fundamentos-de-Node-js/tempCodeRunnerFile.js:7:37)
//     at listOnTimeout (internal/timers.js:555:17)
//     at processTimers (internal/timers.js:498:7)

Es importante estar pendiente todo lo que sucede en nuestras aplicación o programa y si algo tiene una probabilidad de fallar, fallará.

También debemos tener presente que se pueden mitigar estos errores o controlar pues node al detectar un error lo que va a hacer es para todos los hilos que se están ejecutando dando por finalizado nuestro programa y no sabremos en que estado quedo cada hilo de ejecución, por eso será muy clave tener un plan cuando suceda por que estaríamos evitando la finalización de todo el programa.

Conclusión, cuidar nuestro programa e hilo principal, todo lo que se puede ejecutar en asíncrono, ejecútemelo. Frase del día ‘si algo tiene una probabilidad de fallar, fallará’.

Estuve corriendo tres procesos en mi Mac hasta que llegué al minuto 9:10". Para parar un proceso Control + C.

ESTAR MUY MUY MUY PENDIENTES DE AQUELLAS FUNCIONES O PROCESOS QUE PUEDAN LANZAR UN ERROR QUE NO ESTE MANJEADO Y SE DETENGA TODA LA EJECUCIÓN!.

Ahhh es que no había guardado, muy bien Carlos…
Debemos estar muy pendientes de la revisión de nuestro código y cuidar el único hilo de ejecución del que disponemos.

RECORDEMOS, si crees que algo no puede fallar, pues lo hará.

Los ejemplos sencillos, para enfocarnos el punto de explicación, genial

Es muy interesante si campuras el error y lo mandas a la consola, no se detiene el hilo

//Manejo de errores NO se detiene la ejecición
setInterval(() => {
  console.log(i);
  i++;

  if (i === 5) {
    try {
      let a = i + z;
    } catch (err) {
      console.log(err);
    }
  }
}, 1000);```

A todos en algún momento nos pasa que NO GUARDAMOS EL CÓDIGO y nos asusta que algo haya salido mal, pero no siempre es eso.

Si usas VS Code te recomiendo poner el autoguardado después de cada edición de línea, será un segundo que te ahorrarás por cada ejecución de código.

Monohilo= Si no tenemos cuidado suficiente cuando se ejecute un error eso va a parar por completo todo nuestro codigo, tenemos estar atentos con cada detalle!

Muy buena clase, muy buen profesor

hay que tener claro que las funciones asíncronas no se ejecutaran hasta que el callstack se encuentre vació

Esto se pondrá bueno cada vez que se rompa el código… Que Node se apiade de nosotros.

EStar oendiente en el codigo y controlar las validaciones

setInterval(function, milliseconds)
ejecuta la funcion en un tiempo especifico en milisegundos repitiendo continuamente.

Es algo muy bueno a tener en cuenta

Una pregunta:
Pero no seria algo bueno, es decir si hay un error en el threat pool entonces sabemos que es ahi y no en el task stack?
Significa que el proceso se irrumpe cuando se ejecutan las tareas en la “piscina de hilos”?

He probado en la consola del browser y el error se ejecuta infinitamente lol

Cuando el profe da consejos sin parpadear, es que la cosa es seria jejeje 😮

Hola aca les dejo mi repositorio 😄
https://github.com/Juangr1803/Fundamentos-nodejs

Node js es monohilo, por eso tenemos que tener cuidado con los errores, ya que un error que no se ha tratado puede botar toda nuestra app!

👌

Me gusta como explica, se le entiende muy bien.

entendido 😃 tener ojo con los errores

Muy amena la explicación

Lo podemos controlar con un trycatch así:

let i = 0;
setInterval(function () {
  try {
    console.log(i)
    i++;

    if (i === 5) var a = 3 + z;
  } catch (error) {
    console.error(error);
  }
}, 1000);

Muy buena explicación.

jaja si algo puede salir mal, seguramente saldrá mal xd

Genial.

Esta clase me hizo dar mucho miedo! Jajaja