Conocer los conceptos básicos de NodeJS
Instalación de Node.js
Node: orígenes y filosofía
EventLoop: asíncrona por diseño
Monohilo: implicaciones en diseño y seguridad
Configurar las variables de entorno en Node.js
Herramientas para ser más felices: Nodemon y PM2
Cómo manejar la asincronía
Callbacks
Callback Hell: refactorizar o sufrir
Promesas
Async/await
Entender los módulos del core
Globals
File system
Console
Errores (try / catch)
Procesos hijo
Módulos nativos en C++
HTTP
OS
Process
Utilizar los módulos y paquetes externos
Gestión de paquetes: NPM y package.json
Construyendo módulos: Require e Import
Módulos útiles
Datos almacenados vs en memoria
Buffers
Streams
Conocer trucos que no quieren que sepas
Benchmarking (console time y timeEnd)
Debugger
Error First Callbacks
Manejar herramientas con Node
Scraping
Automatización de procesos
Aplicaciones de escritorio
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Al iniciar con el desarrollo en Node.js, es crucial familiarizarse con la documentación oficial. Imagina que estás navegando por un mar de información y necesitarás mantener una brújula que te guíe. Esta documentación ofrece guías detalladas que explican cómo instalar Node.js, las diferentes versiones disponibles, y consejos sobre seguridad. Aquí puedes encontrar:
Explora y utiliza la documentación como tu aliado en el camino del desarrollo.
Los módulos globales son componentes integrados en Node.js que puedes utilizar sin necesidad de importarlos explícitamente. Son como los superpoderes ocultos de Node.js que facilitan tareas comunes. Algunos de los módulos globales más utilizados incluyen:
Console: Imprime mensajes en la consola, útil para depuración.
SetInterval y ClearInterval: Ejecutan funciones repetidamente en intervalos de tiempo específicos. Veamos un ejemplo:
let interval = setInterval(() => {
console.log('Hola');
}, 1000);
setTimeout(() => {
clearInterval(interval);
}, 5000);
En este ejemplo, setInterval
imprime "Hola" cada segundo, y clearInterval
detiene la ejecución después de 5 segundos.
Process: Proporciona información y control sobre el proceso de ejecución de Node.js. Desde variables de entorno hasta información del sistema, es un recurso invaluable para la gestión del entorno.
El manejo de intervalos y ejecución inmediata es fundamental para tareas asíncronas en Node.js. Utilizando setImmediate
, puedes ofrecer prioridad a ciertas funciones, ejecutándolas tan pronto como el motor de JavaScript lo permita.
Por ejemplo, si deseas ejecutar una función después de que el motor haya manejado las operaciones pendientes más urgentes, podrías usar:
setImmediate(() => {
console.log('Ejecutado inmediatamente');
});
Esto ejecuta la función tan pronto como sea posible en el ciclo de eventos. Esta técnica es útil cuando necesitas ajustar las operaciones de tu aplicación y optimizar el rendimiento.
Las variables globales pueden parecer una solución fácil y rápida, pero en realidad pueden causar numerosos problemas. Son como un cuchillo de doble filo. Al compartir un estado global, el riesgo de inconsistencias y errores aumenta significativamente.
En situaciones donde el uso de variables globales es inevitable, gestionarlos con precaución es clave. Optar por módulos especializados o utilizar contextos locales para preservar el estado hace que el código sea más legible y mantenible.
global.miVariable = 'valor global';
console.log(global.miVariable);
A pesar de que es posible definir variables globales de esta manera, se recomienda evitarlas siempre que sea posible. Al adoptar mejores prácticas de desarrollo, fomentarás un entorno de programación saludable y robusto.
Aportes 80
Preguntas 11
No sé ustedes, pero me encanta que tenga inconvenientes en pleno video, que no se vea preparado el arreglo del problema…la vida real esta llena de estos líos y ver cómo los soluciona, eso enseña más que cualquier otro curso. Excelente metodología de trabajo =D
Node funciona a base de módulos, los módulos son el código que permite a Node tener ciertas funcionalidades.
Para que Node funcione correctamente siempre ha de tener sus módulos globales, son aquellos módulos que nos permiten usar la mayoría de funcionalidades básicas y complejas que conocemos de Node, como setTimeout, setInerval, etc.
Estos módulos los podemos usar sin necesidad de importarlos explícitamente en nuestro código, pueden ser usados en cualquier archivo de Node.
Como detalles adicional, setImmediate() es una función asíncrona, por lo que se ejecutará luego de que se libre el hilo principal.
.
Eso quiere decir que si la ejecutas esto
setImmediate(()=>{
console.log('Immediate')
})
console.log('Console 1')
console.log('Console 2')
console.log('Console 3')
console.log('Console 4')
console.log('Console 5')
El resultado será el siguiente, ya que primero se ejecutarán los console.log de manera síncrona y el setImmediate de manera asíncrona 😉
Console 1
Console 2
Console 3
Console 4
Console 5
Immediate
RESUMEN:
Los modulos globales son módulos del core.
Una de las funciones muy usadas en Node es setInterval, clearInterval, para evaluar en n tiempo si el servidor está caído o no.
TIP: Si no tengo que usar variables globales no usarlas, pues son un foco de problemas
console.log(global)
/*Object [global] {
global: [Circular], ---> Dependencias ciruculares.
clearInterval: [Function: clearInterval],
clearTimeout: [Function: clearTimeout],
setInterval: [Function: setInterval],
setTimeout: [Function: setTimeout] {
[Symbol(nodejs.util.promisify.custom)]: [Function]
},
queueMicrotask: [Function: queueMicrotask],
clearImmediate: [Function: clearImmediate],
setImmediate: [Function: setImmediate] {
[Symbol(nodejs.util.promisify.custom)]: [Function]
}
}
*/
require(); // nos va a permitir acceder a caulqueir módulo.
let i =0; // Inicializo contador en cero
let intervalo = setInterval(() => { // Asigno el setInterval a una variable intervalo para poder operarla luego.
console.log(" Alejandro "); // Imprimo mi nombre
if (i === 3){ // Con i ===3 imprima mi nombre hasat que de cero llega a 3 y luego haga clearInterval.
clearInterval(intervalo);
}
i ++;
}, 1000);
setImmediate(()=>{
console.log("Ya mismo")
})
Los módulos globales son muchos módulos que vienen en Node.js que vienen incluidos en módulos globales. En nodejs tenemos el objeto global que tiene métodos y propiedades, a esto es lo que se le llama módulos globales.
Algunos módulos globales:
🔥 Si puedes no usar variables globales, no lo hagas.
Así declaras un variable global:
global.variableGlobal = 'valor'
console.log(variableGlobal)
👀 En node this es un alias de global
this === global
en node es ‘global’ en el navegador es ‘window’
¡Señoras y señores, Nos vamos al espacio!
Code:
let i = 0;
let intervalo = setInterval(() => {
console.log(i);
if (i === 10) {
console.log("¡Despegue! 🚀");
clearInterval(intervalo);
}
i++;
}, 1000);
__dirname y __filename
Son muy usados
😃
let i = 0;
let intervalo = setInterval(() => {
console.log('hola intervalo')
if (i === 3) {
clearInterval(intervalo);
}
i++;
}, 1000);
setImmediate(() => {
console.log('Saludo inmediato');
});
//requiere para agregar modulos a nuestro proyecto
//console.log(process);
//muestra el directorio donde estamos trabajando
console.log(__dirname);
//muestra el directorio y el archivo que temenos abierto
console.log(__filename);
//es buena practica no usar variables globales
global.miVariable = 'mi variable global';
console.log(miVariable);
si puedes no usar variables globales, no uses variables globales, porque eso crea un foco de problemas
Son módulos predeterminados de node y los podemos utilizarlas sin ningún problema, ejemplo:
//Mostrar algo en consola
console.log();
//Mostrar un mensaje en forma de error
console.error();
//Ejecuta un código despues de un intervalo de tiempo
setTimeout(()=>{});
//Ejecuta un código cada intervalo de tiempo
setInterval(()=>{});
//Da prioridad de ejecución
setImmediate(()=>{});
Aca podemos encontrar todos los módulos globales que node trae: https://nodejs.org/api/globals.html#globals_global
evitar al máximo crear variables globales, son mejores los modulos
Los módulos globales son módulos que vienen incluidos por defecto en nuestra versión de nodejs
console.log(global);
nos muestra todos los modulos existentes. esto no se debe hacer en producción.
global es el objeto que contienen todos módulos globales guardados
Evitar siempre que se pueda usar variables globales, son un foco de problemas enormes. Mejor usar módulos o archivos de configuración para luego exportarlos.
require(): se puede utilizar en cualquier lugar para requerir módulos de node js
¿Qué son los módulos del core de Nodejs?
Nodejs posee una cantidad de módulos que forman parte del Core, es decir que forman parte de Nodejs y que no necesitamos descargar de terceros para ser utilizados.
Para revisar el listado de módulos basta revisar la documentación en https://nodejs.org/en/docs/. Dependiendo de la versión de Nodejs que utilices, la cantidad de módulos y las características de ellos pueden variar.
En node existe el objeto global que contiene todos los métodos y propiedades básicas que usamos en Node.
Algunos métodos que incluyen en el global son:
// SET TIMEOUT
// En el ejemplo, llamaria a la consola el "hello world" despues de 3 segundos.
let timeout = setTimeout(function(){
console.log("Hello world");
}, 3000);
// SET INTERVAL
// Llama a otra función cada intervalo de tiempo.
// En el ejemplo, llamaria a la consola el "hello world" cada 3 segundos indefinidamente.
let interval = setInterval(function(){
console.log("Hello world");
}, 3000);
// SET INMMEDIATE
// En el ejemplo, llamaria a la consola el "hello world" inmediatamente.
let immediate = setImmediate(function(){
console.log("Hello world");
});
// CLEAR TIME OUT
// Detiene un setTimeOut, (en este caso el del ejemplo de arriba)
clearTimeOut(timeout);
// CLEAR INTERVAL
// Detiene un intervalo (en este caso el del ejemplo de arriba)
clearInterval(interval);
El objeto global proporciona variables y funciones que están disponibles en cualquier lugar. Por defecto, aquellas que están integradas en el lenguaje o el entorno.
En un navegador se denomina window, para Node.js es global
this hace referencia al objeto contexto en el cual se está ejecutando el código actual.
Hola, tengo una pregunta que a lo mejor suene muy obvia, pero, cual es la diferencia a utilizar un setImmediate a un simple console.log?
Gracias
Módulos que se pueden utilizar sin importar nada, son del core
Usar variables globales podría ser útil para definir configuraciones para toda la aplicación, sin embargo, se considera que no es una buena práctica, por lo tanto, es mejor utilizar las variables de entorno para este propósito.
Estoy viendo varios cursos de forma simultanea, como si de una universidad con sus respectivas clases diarias se tratase. Por este motivo estoy viendo este curso y el de asincronismo de JS. Curiosamente ambos estan justo en el mismo punto en este momento (Callback, promises, async/await, etc.). Es increible como en este entiendo absolutamente todo pero en el Oscar me vuelvo un 8 y casi no comprendo nada. De hecho en su explicacion de Callback y Callback Hell estuve a punto de no ver mas el curso porque no entendi nada. La diferencia esta en la naturalidad con la que Carlos explica todo en este curso.
Un profesor increible ciertamente!
// Globals
// Los modulos globales son funciones ya definidas como funciones globales que vienen dentro de nodejs
// Se encarga de ejecutar despues de cierto tiempo
setTimeout((varr) => {
//...
});
// Ejecuta cada cierto intervalo de tiempo
setInterval((varr) => {
//...
});
// Se encarga de ejecutar inmediatamente
setImmediate((varr) => {
//..
});
// Corta a setTimeOut
clearTimeout((varr) => {
//...
});
// Corta un setInterval
clearInterval((varr) => {
//...
})
// modulos globales de node js https://nodejs.org/api/globals.html
global: objeto donde están guardados todos los módulos globales
/*
Modulos globales,
Es mejor evitar el uso de variables globales ya que son una
fuente de grandes problemas
*/
global.miVariable = 'DANIEL';
let i = 0;
const idInterval = setInterval(function(){
console.log('Hola');
if(i === 3){
clearInterval(idInterval);
}
i++;
}, 1000);
setImmediate(function(){
console.log('Hola');
});
// console.log(process);
console.log(__filename);
console.log(miVariable);```
let i = 0;
let intervalo = setInterval(function () {
console.log("Hola");
if ( i === 3) {
clearInterval(intervalo);
}
i++
}, 1000);
setImmediate(function() {
console.log("Holaa");
});
Existen dependencias circulares
Son funciones que se pueden utilizar según necesitemos en nuestro código y están disponibles en todo el código.
let i = 0
let interval = setInterval(() => {
console.log('Hola')
if (i === 3) {
clearInterval(interval)
}
i++
}, 1000)
setImmediate(() => {
console.log('Hola')
})
console.log(process) /* retorna en consola información muy detallada de los
procesos que esta corriendo */
console.log(__dirname) // muestra el directorio en el que me encuentro
console.log(__filename) // muestra el archivo y su ruta
global.globalVarName = 'value of var'
console.log(globalVarName) // value of var
Nota: Si no es estrictamente necesario usar variables globales, entonces será mejor no usarlas. Puede desencadenar problemas.
Me encanta cuando el maestro tiene “errores” en vivo pues es muy probable que nos pasen a los alumnos.
// Ubicación de ficheros
// console.log(__dirname); //donde estamos en el directorio
// console.log(__filename); //como se llama el archivo en el que estamos
// Timers
// console.log(setInterval)😉
/*
let i=0;
let intervalo = setInterval(function (){
console.log(‘Hola’)
if (i === 3) {
clearInterval(intervalo);
}
i++;
}, 1000);
/
// console.log(clearInterval);
// console.log(setTimeout);
// console.log(clearTimeout);
// console.log(setInmediate);
/
setImmediate(function(){
console.log(‘Hola’);
});
*/
// Modules
// console.log(exports);
// console.log(module);
// console.log(require);
// Seteando variables globales
// global.test = ‘Ejemplo’;
// console.log(test);
// console.log(global.test);
/*
global.miVariable = ‘elvalor’;
console.log(miVariable)
*/
Excelente clase, es genial ver al profesor solucionar problemas en caliente como se suele decir, nos ayuda a como buscar soluciones y demás, Genial 🔥🔥
Los términos que mencionaste están relacionados con Node.js y son elementos clave para entender cómo funciona y cómo se estructuran las aplicaciones en Node.js. A continuación, te proporciono una breve explicación de cada uno:
Global
es un objeto global en Node.js que contiene variables y objetos disponibles en todo el entorno de la aplicación. Sin embargo, se recomienda evitar su uso, ya que puede dar lugar a problemas de encapsulación. En su lugar, se fomenta el uso de módulos para evitar la contaminación del espacio global.setImmediate()
es una función que permite programar la ejecución de una función de devolución de llamada (callback) para que se ejecute en la siguiente iteración del bucle de eventos de Node.js. Se utiliza para realizar operaciones asincrónicas en un momento en el que no se necesita que se realicen inmediatamente.require()
es una función en Node.js que se utiliza para cargar módulos (archivos JavaScript) en una aplicación. Permite importar funciones, objetos y variables desde otros módulos. Es fundamental para estructurar aplicaciones en Node.js.__dirname
es una variable global en Node.js que devuelve la ruta del directorio del archivo actual en el que se encuentra. Se utiliza comúnmente para crear rutas absolutas a otros archivos o directorios.__filename
es una variable global en Node.js que devuelve la ruta completa del archivo actual, incluyendo su nombre. Se utiliza para acceder a la ubicación del archivo en el sistema de archivos.process
es un objeto global en Node.js que proporciona información y control sobre el proceso de Node.js en ejecución. Contiene propiedades y métodos para interactuar con el entorno de Node.js, como gestionar variables de entorno, eventos y señales del sistema, entre otros.Estos conceptos son fundamentales para comprender el funcionamiento de Node.js y cómo se estructuran las aplicaciones en este entorno. Cada uno desempeña un papel importante en el desarrollo y la ejecución de aplicaciones Node.js.
/* Interesting information
Doc: https://nodejs.org/api/globals.html */
// Add new var in global, like a env, but different because is defined in other js
global.projectName = 'Fantastic Nodejs'
console.log(global)
console.log(process)
console.log(__dirname)
console.log(__filename)
let i = 1
let interval = setInterval(() => {
console.log('Infinite loop')
if (i === 3) {
console.log('Stop loop')
clearInterval(interval)
}
i++
}, 1000)
let immediate = setImmediate(()=>{
console.log('Execution Immediate once:', projectName)
})
Creo que el curso de v8 deberia de ser como este, pero ese curso es como ver un panfleto, claro en retrospectiva, porque al ser la primera vez que se ve es interesante.
Variables Globales
Process
Set Immediate
Clear Interval
Globales
globalThis es una variable global que se puede acceder desde cualquier parte del código
ademas globalThis detecta el entorno en el que se esta ejecutando el código
antes de globalThis se usaba window en el navegador y global en nodejs
Globals
¿Cuáles son las variables globales de Nodejs?
Mientras que en el navegador JS posee un objeto window, en Nodejs pueden echar mano de algunas variables.
process
global
module.exports and exports
¿Qué es la variable global de Nodejs?
Es una variable global que es accesible por cualquier script de o programa de node. Se refiere al objeto global. Este tiene propiedades por ejemplo global.process, global.require y global.console.
Cualquier propiedad de primer nivel de global es accesible sin tener que referirse al prefijo global, por ejemplo para global.process se puede hacer referencia directa a process.
¿Cuáles son las propiedades principales de globals en Nodejs?
Existen propiedades principales de global también conocidos como globals.
process
require()
module y module.exports
console y console.log()
setTimeout() y setInterval()
dirname y __filename
__dirname, __filename y process.cwd
__dirname representa el path absoluto a donde se encuentra el archivo en el cual la variable es invocada, mientras que process.cwd es el path absoluto desde donde se esta ejecutando el script, este puede variar si se esta invocando el script desde una ruta distinta a donde este se encuentra node ./src/script.js
__filename es similar a __dirname pero ademas incluye el nombre del archivo como parte del path a este.
Los módulos globales vienen node JS por defecto, los cuales se pueden utilizar según la necesidad que se tenga.
Clear interval puede ser utilizado para limpiar ciertos intervalos, según se defina.
El objeto global proporciona variables y funciones que están disponibles en cualquier lugar. Por defecto, aquellas que están integradas en el lenguaje o el entorno. En un navegador se denomina window , para Node. js es global , para otros entornos puede tener otro nombre.
es.javascript .info
cuando corro el primer console.log en septiembre 2022 XD
Cuando corro el codigo me aparecen 4 veces hola
let i = 0;
let intervalo = setInterval(function() {
console.log('Hola');
if (i === 3) {
clearInterval(intervalo);
}
i++;
}, 1000)
Como aporte, setImmediate es principalmente usado en node.js, pero en navegadores, no es soportado casi, únicamente lo soporte internet explorer v10.
npm = node package manager
uno de los mejores inventos del hombre!
let i = 0
//Puede servir para comprobar la conexión con la base de datos a cada cierto tiempo
//Y después de n intentos cortar el ciclo del setInterval() con clearInterval()
let intervalo = setInterval((function(){
console.log('Hola mundo');
i++
i > 3 ? clearInterval(intervalo) : null
}), 1000);
//directorio en el que nos encontramos
console.log(__dirname)
//archivo en el que nos encontramos
console.log(__filename)
//variable global
global.variableGlobal = 'valor'
console.log(global.variableGlobal)
Probando lo aprendido hasta ahora  que por defecto trae algunos métodos -módulos globales- como:
Lo mejor de estos métodos es que ya están diseñados para ejecutarse, por lo tanto no hace falta que lo llamemos nuevamente sino lo que pasaremos como argumento será un callback que estos métodos ejecutarán.
El objeto Global es un alias para this en Node.js y this es el equivalente a Window en el navegador.
Si puedes evitar crear variables globales, es mejor. No crearlas a no ser que sean estrictamente necesarias
// Imprimimos en pantalla el objeto Global
console.log(global);
// Vemos como funciona el módulo global setInterval
setInterval(() => {
console.log("Hola");
}, 3000);
// Usando el módulo global clearInterval
let i = 0;
const interval = setInterval(() => {
console.log("Hola");
if (i >= 3) {
clearInterval(interval);
}
i++;
}, 1000);
// Usando el módulo global setImmediate
setImmediate(() => {
console.log("Hola");
});
// importar módulos
require();
// acceder al proceso
console.log(process);
// acceder al directorio
console.log(__dirname);
// Acceder al fichero de globales
console.log(__filename);
// crear una variable global
/* si puedes no usar una variable global es mucho mejor */
global.myVariable = 3;
console.log(myVariable);
Algo súper importante es no usar variables globales, pueden llegar a causar muchos errores al no tener tanto control de las otras partes del código que pueden utilizarla o modificarla.
Este profesor es un crack.
¿Entonces cual seria la diferencia entre declarar una variable en el ENV y una variable global?
_dirname
¿Existe algún repositorio del curso?
Suena complejo este core
__filename
cada día se aprende algo nuevo we!
Excelente clase, cosas muchísimo nuevas!!!
Excelente, aprendiendo
😃
Funciones como setInterval y clearInterval, que son globales del sistema se pueden usar para hacer llamadas a una base de datos, si no contesta en determinadas llamadas, una cada segundo se puede retornar un conection lost
Buena clase!
Muy entendible la explicación.
Con esta herramienta van a poder manejar de forma sencilla las versiones instaladas de Node:
El alcance global de node son funciones u objetos que estan definidos de manera global, entre ellos estan setInterval, setTimeout, __dirname, __filename
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?