No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Globals

11/31
Recursos

Aportes 53

Preguntas 8

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

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.

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

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

en node es ‘global’ en el navegador es ‘window’

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

__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

evitar al máximo crear variables globales, son mejores los modulos

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

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.

¿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.

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(()=>{});

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

Aca podemos encontrar todos los módulos globales que node trae: https://nodejs.org/api/globals.html#globals_global

Módulos que se pueden utilizar sin importar nada, son del core

global: objeto donde están guardados todos los módulos globales

require(): se puede utilizar en cualquier lugar para requerir módulos de node js

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

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 ![](

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

__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