Globals

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")
})

Globals

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:

• setInterval
• setImmediate
• require
• __dirname
• __filename

🔥 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’

https://nodejs.org/es/

__dirname y __filename
Son muy usados

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

😃

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

Globales

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");
});

Globals

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

Crear variables globales

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 🔥🔥

Globals

NodeJS Documentation

Node.js Modules

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:

1. Módulos: En Node.js, los módulos son piezas de código reutilizables que se pueden cargar y utilizar en otras partes de una aplicación. Node.js utiliza el sistema de módulos CommonJS, que permite dividir el código en módulos separados y exportar/importar funciones, objetos o variables entre ellos.
2. Global: 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.
3. setImmediate(): 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.
4. require(): 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.
5. __dirname: __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.
6. __filename: __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.
7. process: 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.

Fuente

https://nodejs.org/api/globals.html#global-objects

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)

https://nodejs-es.github.io/api/globals.html

Probando lo aprendido hasta ahora ![](

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.

Los módulos globales en Node.js son módulos que vienen por defecto incluidos de forma global.

En la documentación de Node.js podemos encontrar toda la información acerca del objeto global y los módulos globales

Global objects | Node.js v16.10.0 Documentation

En Node tenemos al objeto Global (Window en el navegador) que por defecto trae algunos métodos -módulos globales- como:

• setTimeout: una función asíncrona la cual podremos asignarle un tiempo para ejecutarse
• setInterval: función asíncrona que se repetirá por intervalos
• clearInterval: detenemos el proceso de setinterval
• process
• console
• exports
• setImmediate: es una función asíncrona que en vez de esperar un tiempo para ejecutarse lo hará de inmediato

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

nodejs.org

__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:

https://github.com/nvm-sh/nvm

Node.js v15.4.0 Documentation

El alcance global de node son funciones u objetos que estan definidos de manera global, entre ellos estan setInterval, setTimeout, __dirname, __filename