No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Globals

11/31
Recursos

Aportes 76

Preguntas 11

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

No s茅 ustedes, pero me encanta que tenga inconvenientes en pleno video, que no se vea preparado el arreglo del problema鈥a 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 鈥榞lobal鈥 en el navegador es 鈥榳indow鈥

__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

Recuerden que desde ES2020 el objeto global es 'globalThis' independientemente del entorno (browser, node y webworker)

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 鈥渆rrores鈥 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(鈥楬ola鈥)
if (i === 3) {
clearInterval(intervalo);
}
i++;
}, 1000);
/
// console.log(clearInterval);
// console.log(setTimeout);
// console.log(clearTimeout);
// console.log(setInmediate);
/

setImmediate(function(){
console.log(鈥楬ola鈥);
});
*/

// Modules
// console.log(exports);
// console.log(module);
// console.log(require);

// Seteando variables globales
// global.test = 鈥楨jemplo鈥;
// console.log(test);
// console.log(global.test);
/*
global.miVariable = 鈥榚lvalor鈥;
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 馃敟馃敟

**OBJECTO GLOBAL** *El **objeto** **global** en* **Node.js***, **conocido** como **global**, es un **objeto** que est谩 **disponible** en **todos** los **m贸dulos** y **scripts sin necesidad** de **importarlo** **expl铆citamente**. **Similar** a **window** en los **navegadores** **web**, **global** **proporciona** un **espacio** de **nombres** **compartido** **donde** se pueden **definir** **variables**, **funciones** y **objetos** que deben ser **accesibles** en **cualquier** **parte** de la **aplicaci贸n**. **Adem谩s** de los **propios elementos definidos** por el **usuario**, **global** **incluye** **variables** y **funciones** **integradas** de* **Node.js***, como:* * **process** * **Buffer** * **setTimeout** * **console** ***Aunque** el **uso** de **global** puede **ser** **煤til** para **ciertas** **tareas**, su **uso** **excesivo** puede **llevar** a **problemas** de **mantenimiento** y **colisiones** de **nombres**, por lo que es **recomendable** **emplearlo** con **precauci贸n**.*
En Node.js, el objeto `global` es un objeto global especial que proporciona acceso a ciertas funciones y objetos en todo el entorno de ejecuci贸n de Node.js. Contiene referencias a varios elementos, incluidas funciones para la gesti贸n del tiempo as铆ncrono (como `setTimeout`, `setInterval`, `setImmediate`, etc.), as铆 como otras funcionalidades 煤tiles. Aqu铆 hay una explicaci贸n de algunos de los elementos m谩s comunes del objeto `global` en Node.js: \- `global.setImmediate()`, `global.clearImmediate()`: Estas funciones se utilizan para programar una funci贸n que se ejecutar谩 en la pr贸xima iteraci贸n del bucle de eventos. `clearImmediate()` se utiliza para cancelar una funci贸n programada para ejecutarse con `setImmediate()`. \- `global.setTimeout()`, `global.clearTimeout()`: Estas funciones se utilizan para programar la ejecuci贸n de una funci贸n despu茅s de un retraso espec铆fico (en milisegundos). `clearTimeout()` se utiliza para cancelar la ejecuci贸n de una funci贸n programada con `setTimeout()` antes de que ocurra. \- `global.setInterval()`, `global.clearInterval()`: Estas funciones se utilizan para programar la ejecuci贸n repetida de una funci贸n con un intervalo de tiempo espec铆fico (en milisegundos). `clearInterval()` se utiliza para detener la ejecuci贸n de una funci贸n programada con `setInterval()`. \- `global.queueMicrotask()`: Esta funci贸n se utiliza para encolar una microtarea que se ejecutar谩 antes de que se complete la ejecuci贸n del bucle de eventos actual. Es similar a `process.nextTick()` pero con prioridad ligeramente menor. Adem谩s de estas funciones para el manejo del tiempo y las microtareas, el objeto `global` tambi茅n puede contener otras funciones y objetos 煤tiles, como `fetch` (para hacer solicitudes HTTP), `crypto` (para operaciones criptogr谩ficas), y `performance` (para medir el rendimiento del c贸digo). Es importante tener en cuenta que, aunque `global` proporciona acceso global a estas funciones y objetos, es una buena pr谩ctica limitar su uso y, en su lugar, importar solo lo que sea necesario para cada m贸dulo espec铆fico. Esto ayuda a mantener un c贸digo m谩s modular y evita posibles conflictos de nombres y problemas de mantenimiento a largo plazo.

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

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

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