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
Aportes 72
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’
__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);
¡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);
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 🔥🔥
/* 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?
o inicia sesión.