Crea una cuenta o inicia sesi贸n

隆Contin煤a aprendiendo sin ning煤n costo! 脷nete y comienza a potenciar tu carrera

Configurar las variables de entorno en Node.js

5/31
Recursos

Aportes 158

Preguntas 29

Ordenar por:

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

Para ingresar las variables con PowerShell primero hay que definirlas escribiendo:

$env:NOMBRE="Carlos"

Una vez definido ejecutan el comando

node conceptos/entorno.js

En caso de querer tener variables de entorno en un archivo, puede utilizar dotenv, de esta manera puede crear el archivo .env y ah铆 configurar las variables necesarias.
Y luego accederlas donde las necesite, ejemplo:

file.js:

require('dotenv').config();
console.log(process.env.NAME);

.env

NAME = 'u name'

Se suele utilizar mucho para variables de bases de datos, usuarios, etc.
Y en caso de usar variables con informaci贸n sensible, tener en cuenta nunca enviar el archivo .env al repositorio (:

RESUMEN:


Las variables de entorno son una forma de llamar informaci贸n de afuera a nuestro software, sirve para definir par谩metros sencillos de configuraci贸n de los programas de modo que puedan ejecutarse en diferentes ambiente sin necesidad de modificar el c贸digo fuente de un script.

El objeto process nos da informaci贸n sobre el procesos que est谩 ejecutando este script.
La propiedad env es la que nos da acceso a las variables de entorno de manera sencilla.

//Veremos como desde cualquier sitio fuera del entorno podemos meter informaci贸n adentro.

let ejemplo ="Alejandro-sin" //Esta variable la declar茅 aqu铆 y puedo llamarla aqu铆.

//驴Qu茅 ocurre cuando quiero llamar un valor que no va dentro del software, si quiereo llamar una API, o que necesito una clave, o un token?

//+ El c贸digo no  deber铆a guardar este tipo de valores credenciales y por esto existen las variables de entorno. Si grabasemos estos datos estar铆amos obligados a cambiar el c贸digo del programa cada vez que se ejecutan en lugares diferentes, dificultando el despliegue.

//+ Por buenas pr谩cticas heredadas de Linux las variables de entorno que vengan desde fuera (process.env.VARIABLE ) se ponen en may煤scula y se separan mediante guion bajo en vez de espacio.


let nombre = process.env.NOMBRE || 'Sin nombre'; 
let web = process.env.MI_WEB || 'no tengo web';
var apiKey = process.env.APIKEY || 'HF33o9oERVERVEEEEs';

console.log('Hola '+ nombre);
console.log('Mi web es '+ web);

// Me retornara { Hola Sin nombre, mi web es notengo web} ya que tiene  la expresi贸n OR || me asigna estas variables por defecto

// Para que las variables de entorno me tomen valores puedo hacer varias cosas:

//+  Desde la terminal asignarle las variables antes del codigo:

< NOMBRE:"Alejandro" MI_WEB"123QWERTY" APIKEY=10937472 node conceptos/entorno.js >

Soluciones r谩pidas Windows 10:

---- Si deseas usar Powershell:

$env:NOMBRE=鈥渢uNombre鈥 ; node entorno.js
( de ese modo es posible enviar los 2 comandos a las vez)

----- usar CMD o cambiar Visual a CMD

  1. desplegar las opciones de consola de Visual Studio Code.
  2. click en 鈥渟eleccionar el shell predeterminado鈥
  3. seleccionar 鈥渃ommand prompt鈥
  4. SET NOMBRE=tuNombre & node entorno.js
    ( de ese modo es posible enviar los 2 comandos a las vez)

Este post habla un poco m谩s a fondo como manejar variables de entorno en un proyecto de node.js. Lo comparto: https://medium.com/@jairofernandez/manejo-de-variables-de-entorno-en-node-js-ac90f7a2c1e5

VARIABLES DE ENTORNO

- Se declaran como:                                      process.env.NOMBRE_VARIABLE en el archivo JS
- Para llamarla en BASH (GITBASH por ejemplo) ser铆a:     NOMBRE=Roberto node archivo.js
  Se pueden poner varias al mismo tiempo:                NOMBRE=x APELLIDO=z node archivo.js (Con un espacio se separan)
- En windows primero se hace:                            SET NOMBRE_VARIABLE=VALOR
  Luego:                                                 node archivio.js               
- Para ponerle un valor por DEFAULT:                     process.env.NOMBRE_VARIABLE || 'Valor por default' en el archivo JS

- Las variables de entorno se ponen en mayusculas (viene desde que se usaban en servidores Linux)

Les dejo mis apuntes usando Notion de esta clase ^^

Variables de entorno


Si no queremos que un valor que vaya dentro del software, vamos a tener que usar variables de entorno. Para crear una variable de entorno en JS, escribrimos:

let nombre = process.env.NOMBRE
console.log(`Hola ${nombre}`)

鈿 Cuando ejecutemos el archivo en la terminal, nos dir谩 que la variable de entorno est谩 undifined. Para resolver esto hay que definirla antes de ejecutar el archivo.

NOMBRE=Carlos node archivo.js

Si queremos definir una variable por defecto, ser铆a con ||

let nombre = process.env.NOMBRE || 'sin nombre'

Buenas pr谩cticas

  • Siempre definir tus variables de entorno en May煤sculas, y si necesitas separar palabras, usar underscore _

a mi en powershell me funciono de la siguiente forma

$env:NOMBRE="camilo"; node entorno.js

Con el paquete dotenv, podemos definir las variables de entorno en un archivo externo .env

Buena clase. En ocasiones tenemos muchas variables de entorno que pueden cambiar. Por ejemplo, al hacer un deploy en ambiente de desarrollo se quiere apuntar a la base de datos de desarrollo. Mientras un deploy en producci贸n se quiere apuntar a esa base de datos. Esto se maneja desde las variables de entorno.

Existe una manera de tener un archivo llamado 鈥.env鈥 que vivir谩 en la ra铆z del proyecto en el que se pueden definir todas estas variables de entorno a utilizar y si quisieramos, podr铆amos definirlo dentro de nuestro git ignore y no tenerlo visible en el repositorio por motivos de seguridad. M谩s info ac谩: https://www.npmjs.com/package/dotenv

Tambien podemos usar un archivo para definir las variables de entorno sin necesidad de hacerlo en la consola 馃槃.

.

  • Intalamos dotenv
npm install dotenv

.

  • En el archivo .env
NAME=Juan
WEB=https://github.com/Juangr1803/Fundamentos-nodejs
  • Resultado
 node concepts/entorno.js
Hello JGR
Hello my web is https://github.com/Juangr1803/Fundamentos-nodejs

Las variables de entorno son las variables que vienen desde fuera del sistema y se pueden referenciar con 鈥減rocess.env.VARIABLE鈥, estas deben ir con MAY脷SCULAS.

Para establecer una variable en window en cmd
Set NOMBRE=Francisco

Excelente clase, aprendiendo conceptos nuevos. Estoy muy emocionado!!! Si alguien est谩 aqu铆 como yo, en la ruta de desarrollo backend con JS鈥 Comentar!!! 馃槃

A mi me funsiono de la siguiente manera en PowerShell desde Windows

PS F:\code\nodejs> $env:NOMBRE="Fer"
PS F:\code\nodejs> node monohilo.js

Para los que no puedan realizar el ejercicio creando las variables de entorno lo pueden intentar primero realizar este comando en consola.

$env:NOMBRE="Oscar"

Despu茅s de poner el comando. Ejecuten el siguiente comando.

node ruta-del-archivo.js
let nombre = process.env.NOMBRE || 'Sin nombre'; /* El o sin nombre es para que arroje ese resultado en caso de que no se este enviando el nombre de manera externa. */
let web = process.env.WEB || 'No tengo web';



console.log(`Hola ${nombre}`);
console.log(`Mi web es ${web}`);

/* Directamente en node puedes definir el nombre de las variables y lo escribes antes de realizar el comando de ejecucion de tu archivo .js quedaria algo asi:

NOMBRE=nombreDeLaPersona node archivo.js */

/* Las variables de entorno se colocan en mayuscula con estilo snake_case example 'WEB' 'MY_WEB' esto es por convencion y buenas practicas. */

Mi web es localhost

No s茅 qu茅 pasa, me sale el siguiente error.

Tambi茅n se puede usar el operador ?? en lugar de || a partir de ES6. Este operador (??) comprueba que el valor a la izquierda sea realmente null o undefined mientras que el operador || comprueba que sea falso. En ocasiones un valor de falso puede venir de datos vac铆os que son v谩lidos, por ejemplo una cadena vac铆a 鈥溾.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator

  1. Abre la paleta de comandos usando Ctrl + Shift + P
  2. Tipea- Select Default Shell
  3. Seleccione Git Bash de las opciones
  4. Haga clic en el icono 鈥+鈥 en la ventana de la terminal
  5. La nueva terminal ahora ser谩 una terminal de Git Bash.

No me funcion贸 el ejemplo


//variables de entorno en mayusculas
let nombre = process.env.NOMBRE || 'sin nombre';
let web = process.env.WEB||'no tengo WEB';

console.log('hola '+nombre);
console.log('mi web es :'+web);

Comando para NodeJS 2021 Jun

En windows primero se hace:
SET NOMBRE_VARIABLE=VALOR
Luego:
node archivio.js

Pueden probar este paquete de NPM, que te permite usar un archivo aparte llamado .env, donde agregues todas las variables de entorno que necesites.
https://www.npmjs.com/package/node-env-file

 var env = require('node-env-file');
 env(__dirname + '/.env');

Este profesor, lo hace m谩s sencillo todo. Excelente clase!!

驴A que se refiere con Tokens? 驴Que son?

Si usas powerShell, antes de ejecutar el comando node file.js Debes ejecutar el comando para guardar el valor de la variable de estado ser铆a: `$env:NOMBRE="Carlos"` luego si ejecutas el comando `node File.js` y funcionar谩 :)

Asi la ejecute con powershell

$env:NOMBRE=鈥渏ulian鈥; node index.js

Los comandos no me funcionanban, desde la terminal de visual studio code, instale el paquete dotenv => npm install dotenv y puede continuar con el curso, espero les sirva.

Aqui les dejo una lectura para que conozcan un poco mas sobre las variables de entorno y su importancia:Click Aqui

let nom = process.env.NOMBRE || 鈥榮in nombre鈥;
console.log('Hola '+ nom);
NOMBRE=Myname node .\enviroment.js # Ejecuci贸n de variables de entorno.

Para poder ingresar variables desde afuera primero tenemos que acceder a ella desde nuestro programa. Esto se hace con el metodo 鈥榩rocess.env鈥 de la siguiente manera:

let nombre = process.env.NOMBRE;

donde para poder definirlo tenemos que escribir al momento de ejecutarlo el

NOMBRE=JOEL node carpeta/archivo.js

Si queremos utilizar un valor por defecto podemos utilizar el signo de OR de la siguiente forma:

let nombre = process.env.NOMBRE || 'Sin Nombre';

En el caso de que tengamos mas de una variable, podemos tener todo configurado, solo poner el nombre de la nueva variable y al momento de ejecutarla ponemos

NOMBRE=JOEL WEB=joel.com node carpeta/archivo.js

Asi con todas las variables que queremos.

Una buena practica es tener que todas las variables de entorno sean en MAYUSCULAS Y divididas por un guion bajo sus espacios.

BOUNUS - BUENA PRACTICA
Les dejo una buena pracica que me dejo esta clase.
Antes de correr node, no se olviden de guardar los cambios! 馃槂 馃槂 馃槂 command+s en mac!
PlatziSalu2! 馃槂

Les recomiendo que cambien la terminal a una basada en unix como git para que funcione variables de entorno

cuando se crean las variables de entorno y se inicializan con un valor, ya pueden ser accedidas desde cualquier parte de la aplicaci贸n?

Variable de entorno. Datos que no est谩n dentro del c贸digo y se pueden tener en un archivo .env es una buena practica, en los frameworks se usa

Por primera vez entiendo totalmente el concepto de los hilos de node.

[]
MAC Agosto 2023

<
Definir variable
export MI_VARIABLE=mi_valor

Para ejecutar:
echo $MI_VARIABLE 

(url)

Si usan CMD es:
set NOMBRE=tuNombre

Crear variables de entorno

El m贸dulo principal process de Node.js proporciona la propiedad env la cual almacena todas las variables de entorno que fueron definidas al momento que empez贸 el proceso.

El siguiente c贸digo corre app.js estableciendo USER_ID yUSER_KEY.

BASHcopy
USER_ID=239482 USER_KEY=foobar node app.js

Esto pasar谩 el USER_ID como 239482 y el USER_KEY como foobar. Esto es apropiado para testing, sin embargo para production, probablemente sea mejor configurar BASH scripts para exportar las variables.

process no requiere el uso de 鈥渞equire鈥, porque est谩 autom谩ticamente disponible.

En el siguiente c贸digo se accede a las variables de entorno USER_ID yUSER_KEY que fueron establecidas previamente.

JScopy
let userID = process.env.USER_ID // "239482"
let userKey = process.env.USER_KEY // "foobar"

De la misma manera se puede acceder a cualquier variable de entorno configurada.

Lo que puede ocurrir es que las variables de entorno no siempre se hayan definido, por lo que es 煤til que en nuestro programa les asignemos unos valores predeterminados. Esto lo podemos conseguir con un c贸digo como este:

JScopy
let userID = process.env.USER_ID || 'defaultUserID'
let userKey = process.env.USER_KEY || 'defaultUserKey'

Si en un proyecto de Node.js se tiene muchas variables de entorno, se puede crear un archivo .env en el directorio ra铆z del proyecto, y luego usar el paquete dotenv para cargar las variables durante el tiempo de ejecuci贸n (runtime).

BASHcopy
# .env file
USER_ID="239482"
USER_KEY="foobar"
NODE_ENV="development"

En el archivo de JavaScript

JScopyrequire('dotenv').config();
process.env.USER_ID // "239482"
process.env.USER_KEY // "foobar"
process.env.NODE_ENV // "development"

Tambi茅n se puede correr el archivo JavaScript con el comando node -r dotenv/config index.js si no se quiere importar el paquete en el c贸digo.

Fuente: How to read environment variables from Node.js

Una dependencia muy 煤til para manejar las variables de entorno es dotenv, ya que nos permite definirlas en un archivo .env para despu茅s leerlas y colocarlas directamente en el process.env

Cabe recordar que podemos leer variables de entorno creadas por nuestro sistema operativo, en linux podemos listar todas las variables con el comando env y podemos imprimir sus valores directamente:

console.log("PS1:" + process.env.PS1);
console.log("User:" + process.env.USER);

Variables de entorno

  • Para poder acceder a las variables de entorno lo hacemos con process.env.NOMBRE_VARIABLE_DE_ENTORNO
  • Por convenci贸n y buenas practicas las variables de entorno son en may煤sculas y separadas por un guion bajo en caso de tener dos palabras o mas

.
驴C贸mo har铆amos para desde afuera mandar variables de entorno con sus valores a la ejecuci贸n de nuestro programa?
se la enviamos por la terminal junto con el comando de ejecuci贸n del programa

NOMBRE_VARIABLE="valor" node programa.js

incluso podemos mandar varias

NOMBRE_VARIABLE="valor" NOMBRE_VARIABLE_DOS="otro valor" node programa.js

Ejemplo
entorno.js:

let nombre = process.env.NOMBRE 
console.log('hola',nombre)

si ejecutamos el archivo entorno.js

node entorno.js // hola undefined

veremos en consola hola undefined , undefined donde esta la variable de entorno NOMBRE, por que no se la hemos mandado desde afuera hacia la ejecuci贸n del programa, para poder mandarle la variable de entorno con su valor desde afuera lo hacemos desde la terminal de esta forma

NOMBRE="juan" node entorno.js 

en consola veremos hola juan
.
si quisi茅ramos enviar 2 valores de 2 variables de entorno
entorno.js:

let nombre = process.env.NOMBRE 
let web = process.env.MI_WEB
console.log('hola',nombre)
console.log('mi web es',web)

lo har铆amos as铆

NOMBRE="juan" MI_WEB="juan.com" node entorno.js

en consola ver铆amos

hola juan 
mi web es juan.com 

tambi茅n podemos darle valores por defecto a las variables de entorno en caso de no mandar desde afuera nada

let nombre = process.env.NOMBRE || 'juan' 
let web = process.env.MI_WEB || 'juan.com'

entorno.js:

let nombre = process.env.NOMBRE || 'juan' 
let web = process.env.MI_WEB || 'juan.com'
console.log('hola',nombre)
console.log('mi web es',web)

si ejecutamos en la terminal

node entorno.js 

veremos en consola el valor por defecto asignado a las variables

hola juan 
mi web es juan.com 

Les comparto mis notas para que se ayuden con el estudio 馃檶馃敟
https://platzi.com/tutoriales/1759-fundamentos-node/9490-notas-curso-de-fundamentos-de-nodejs-notion/

Algunos ejemplos de variables de entorno:

  • Direcci贸n y Puerto HTTP
  • Credenciales de bases de datos
  • Ubicaci贸n de archivos y carpetas est谩ticas
  • Credenciales APIs externas

Configurar las variables de entorno en Node.js
Realizar un request y utilizar una variable para imprimirla.

//El objeto process nos da informaci贸n sobre el proceso que est谩 ejecutando este script.
//La propiedad env es la que nos da acceso a las variables de entorno de manera sencilla.
let nombre = process.env.NOMBRE || 鈥淪in nombre鈥;

console.log('Hola '+ nombre);
//NOMBRE=Juan node first.js - Bash
//POwershell $env:NOMBRE=鈥淐arlos鈥

Para usar el archivo .env es necesario insatalar el dotenv

npm i dotenv -D

agregamos el require al inicio de nuestro archivo y listo!

require('dotenv').config();

Ya se puden usar las variables de entorno que declares en tu archivo .env

esto es un tutorial de varible de entorno

/home/alexander/Descargas/fundamentos-node-platzi-master.zip

Las variables de entorno sirven por ejemplo para tener al alcance mails, direcciones, urls, ip鈥檚, tokens de API鈥檚, etc.

Las utilizamos as铆:

let nombre = process.env.NOMBRE;
console.log(`Hola ${nombre}`)

// en la consola lo siguiente:
NOMBRE=Juan node entorno.js

//output:
Hola Juan

Buena pr谩ctica:

  1. La 煤ltima partecita de las variables de entorno van siempre en may煤scula.
  2. Si consiste en m谩s de una palabra, se utiliza el underscore para separar. Por ejemplo:
let web = process.env.MI_WEB

Podemos tambi茅n utilizar valores por defecto:

let nombre = process.env.NOMBRE || 'desconocido';
console.log(`Hola ${nombre}`)

// en la consola lo siguiente:
node entorno.js

//output:
Hola desconocido

intente varias veces y no pude unir mi nombre con el saludo.
Pero en varios intentos escribe:
SET NOMBRE=mi nombre & node entorno.js
y me resulto: hola guillermo

Para los que quieran cambiar de powersheell o cmd en vscode y ponerle git bash, dejo un video que seguro les sirva mucho.

https://www.youtube.com/watch?v=EVh36sDppcs

Las variables de entorno se emplean cuando traemos un valor externo al programa, como el de una API.

Las variables de entorno nos sirven para captar info que venga desde fuera de app.

  • variables de entorno: process.env.NombredeVariable, lo ideal es usarlo para evitar el uso de credenciales importantes dentro del c贸digo.
  • como buena practica variables de entorno siempre en may煤scula.

las variables de entorno sirven para guardar datos NO SECRETOS.

si trabajan desde Linux las variables de entorno de entorno se pueden definir en el archivo ~/.bashrc (ojo con el punto al inicio del nombre del archivo, si no lo pones crearas otro archivo), solo tienes que editar el archivo y agregar las variables al principio o al final del archivo asi:
NOMBRE="Luis"
WEB="mi web"
Luego ejecutas el comando:
source ~/.bashrc
para recargar bash, o solo reinicia la consola, luego podr谩s consultar la variable ya definida as铆:
echo $NOMBRE
Y va a imprimir el nombre que le hayas asignado y podr谩s acceder a ella como vimos en esta clase

El futuro entorno que sustituir谩 a todos, en un m谩ximo de 5 a帽os

// ** VARIABLES DE ENTORNO **

// Para pasar el valor a nombre en la consola escribr NOMBRE=Omar node conceptos/entorno.js
let nombre = process.env.NOMBRE || "rroderickk";
let miWeb = process.env.MI_WEB || "https://github.com/rroderickk/node.git";

console.log(`Hola ${nombre}. Mi web es ${miWeb}`);
let nombre = process.env.NOMBRE || ' ';
let web = process.env.WEB || 'no tengo web';

console.log('Hola ' + nombre);
console.log('Mi web es ' + web);```
	//Variables de entorno

let nombre = process.env.NOMBRE || 'Sin nombre';
let web = process.env.MI_WEB || 'no tengo web';

console.log('Hola '+ nombre);
console.log('Mi web es '+ web);


//En Consola (NOMBRE=Carlos node conceptos/entorno.js)
//            NOMBRE=Carlos MI_WEB=loquesea.com node conceptos/entorno.js
//Respuesta   (Hola Carlos
//            Mi web es loquesea.com)```

Excelente clase.

// ** VARIABLES DE ENTORNO **

// Para pasar el valor a nombre en la consola escribr NOMBRE=Omar node conceptos/entorno.js
let nombre = process.env.NOMBRE || "Mauricio";
let miWeb = process.env.MI_WEB || "No tengo web :(";

console.log(`Hola ${nombre}. Mi web es ${miWeb}`);

驴C贸mo declara variables seg煤n tu sistema operativo y terminal?

  • Windows

    • CMD: setx VARIABLE=VALOR
    • POWER SHELL: $env:VARIABLE=VALOR
  • LINUX:

    • Ubuntu: export VARIABLE=VALOR.

En MacOS no se, alguien que coloque como se realiza.

Las variables de entorno, son recomendables crearlas en may煤scula y si es m谩s de una palabra, separarlas con _ por ejemplo: MI_WEB.

// Acceder a el proceso.
let nombre = process.env.NOMBRE || 'Sin nombre';
let web = process.env.WEB || 'no tengo web';

console.log('hola ' + nombre);
console.log('Mi web es: ' + web);```

My notes

Variables de Entorno
Desde fuera de js meter cualquier variable a nuestro proceso, con las variables de entorno, y que esa informaci贸n se ejecute en tiempo real

No me funciona si alguien me puede colaborar.

let nombre = process.env.NOMBRE;

console.log("Hola " + nombre);

PS C:\Users\Zagro\Documents\nodejs> NOMBRE=Santiago node clase1.js
NOMBRE=Santiago : The term 'NOMBRE=Santiago' is not recognized as the name of a
cmdlet, function, script file, or operable program. Check the spelling of the name,
or if a path was included, verify that the path is correct and try again.
At line:1 char:1
+ NOMBRE=Santiago node clase1.js
+ ~~~~~~~~~~~~~~~~~
    + CategoryInfo          : ObjectNotFound: (NOMBRE=Santiago:String) [], CommandNot
   FoundException
    + FullyQualifiedErrorId : CommandNotFoundException

Como se definen las variables de entorno,
Estoy probando en windows

C:\Users\admin\Desktop\practica_platzi\video05>NOMBRE=JS node entorno.js
"NOMBRE" no se reconoce como un comando interno o externo,
programa o archivo por lotes ejecutable.
let name = process.env.NAME_PERSON || "Not name";
let web = process.env.WEB_PERSON || "Not web";

console.log("hi ", name);
console.log("your web is ", web);


//Es buena practica usar las variablesde entorno en mayusculas

let nombre = process.env.NOMBRE || 'Sin nombre';
let web = process.env.WEB || 'no tengo web';


console.log(`Hola ${nombre}`);
console.log(`Mi web es: ${web}`);

Bueno con VSC en windows se puede solucionar agregando a VSC la termina bach,.

Funciona para widnows 10, tener en cuenta que se debe cambiar \ por /
鈥淐:\Program Files\Git\bin\bash.exe鈥

y funciona super


const NAME = process.env.NAME || 'Sin Nombre'
console.log(` Mi nombre es: ${NAME}`);

// node 1_variable_entorno.js
// => Mi nombre es Sin nombre

// NAME=jesus node 1_variable_entorno.js
// => Mi nombre es jesus

Variables de entorno

let nombre = process.env.NOMBRE || 'sin nombre';
let web = process.env.WEB || 'no tengo web';
console.log('Hello' + nombre);
console.log('My Web ' + web);

NOMBRE=BrandoRodriguez node entorno.js
WEB=BrandoRodriguez node entorno.js

Para los que est谩n usando mac version Catalina, el terminal est谩 en default en zsh, para poder utilizar el mismo c贸digo que Carlos, hay que cambiarlo a bash donde dice 鈥1: bash鈥 en la barra de la terminal del Visual Studio Code

Para establecer un valor a la variable NOMBRE desde la terminal se puede hacer de la siguiente forma

Set NOMBRE = Nietsnie
node conceptos/entorno.js

Variables de entorno en Node.js

Using environment variables in Node.js requires the following sintaxis:
NAME_VARIABLE
(used in the old linux environments 馃槃)
we can use into the program those variables by passing them into the moment of execution.

const name = process.env.NAME;

console.log(`Hello ${name}`)

Variables de entorno

Son variables que est谩n en el scope global y pueden ser accesibles desde cualquier parte de nuestro c贸digo.

Declaramos estas variables con el fin de no exponer dentro de nuestro c贸digo datos sensibles como contrase帽as, urls, tokens de APIS, correos, IPS y otros mas.

Para ser usadas, podemos realizarlo de la siguiente manera:

let nombre = process.env.NOMBRE || 'sin nombre'; //declaramos nuestras variables de entorno en may煤scula ya que son datos constantes. Adem谩s contiene valores por defecto en caso de no encontrar ninguna variable con ese nombre.
let web = process.env.MI_WEB || 'no tengo web';

console.log(`Hola mi nombre es ${nombre} y mi web es ${MI_WEB }`);

// corremos el c贸digo de la siguiente manera: NOMBRE=Manuel WEB=mooenz.com node ejemplos.js 
// nos da como resultado:
// Hola mi nombre es Manuel y mi web es mooenz.com

environment.js

// 1: npm install dotenv
// 2: node .\environment.js
require('dotenv').config();

let name = process.env.NAME || 'Guest'

console.log(`Hello ${name}`)

.env

NAME="Edgar"

Si quieren usar la misma consola que carlos 隆隆隆Deben instalar git antes en este link lo pueden descargarLe dan a todo siguiente. pueden seguir este video para usar esa consola

Aunque puedo definir la variable de entorno me sigue saliendo undefained para solucionarlo tuve que agregarla al entorno global usando export

  • export NOMBRE=juan

de esta forma me funciono el ejemplo sin problema, usando Linux

El ejercicio, aunque me gener贸 problemas al incicio por la vriable se la pudo solventar con los aportes realizados, muchas gracias.

let nombre = process.env.NOMBRE;

console.log('Hola 鈥 + nombre);

PS C:\Users\pc\Desktop\Platzi\Nodejs> node .\entorno.js
Hola Walter
PS C:\Users\pc\Desktop\Platzi\Nodejs>

Variables de entorno

let name = process.env.NAME || 'Sin nombre'
let web = process.env.WEB || 'No tengo web'
console.log(`Hola ${name}`)
console.log(`mi web es: ${web}`)

Las variables de entorno permiten obtener informaci贸n desde afuera de nuestro software, o informaci贸n que varia y es dada por el usuario.

C贸mo asignarlas

let <variable_name> = process.env.<VAR_NAME> || <default_value>

Al ejecutar en la consola, se puede asignar un valor de la siguiente forma

<VAR_NAME>='VALUE' node <file_url>

Una variable de entorno es una variable din谩mica que puede afectar al comportamiento de los procesos en ejecuci贸n en un ordenador.

Las variables de entorno son variables externas al c贸digo fuente del programa que se utilizan para configurar su comportamiento. Estas variables permiten separar la configuraci贸n del c贸digo y son especialmente 煤tiles para gestionar diferentes configuraciones en entornos de desarrollo, prueba y producci贸n. Importancia de las Variables de Entorno Separaci贸n de Configuraci贸n y C贸digo: Mantiene la configuraci贸n fuera del c贸digo, lo que facilita cambiar configuraciones sin modificar el c贸digo. Seguridad: Evita la exposici贸n de informaci贸n sensible (como claves de API, contrase帽as) en el c贸digo fuente. Facilidad de despliegue: Permite usar diferentes configuraciones en distintos entornos (desarrollo, prueba, producci贸n) sin cambiar el c贸digo. Portabilidad: Facilita mover la aplicaci贸n entre diferentes entornos y sistemas sin cambios en el c贸digo.
utilizando exactamente lo que explico me da error y he estado tiempo buscando y nada
Realizo exactamente lo que me dice y no me da error
Algunas novedades de Node.js respecto a la lectura de las variables de entorno... <https://platzi.com/tutoriales/1759-fundamentos-node/36778-lectura-de-variables-de-entorno-de-forma-nativa-nodejs/>
Puedes utilizar <u>dotenv</u> para leer tus variables de entorno. Esto requer铆a **instalar** el paquete e **importarlo** en cada archivo donde lo necesites, as铆: **file.js** ```js require('dotenv').config(); ``` **驴Qu茅 pasa ahora?** Desde la **versi贸n 20.6** de **Node.js** de **forma nativa** podemos leer las variables de entorno desde un fichero **sin la necesidad de instalar paquetes**. ![](https://www.google.com/url?sa=i\&url=https%3A%2F%2Fwww.wattpad.com%2F1140676287-memes-han-pasado-84-a%25C3%25B1os\&psig=AOvVaw0mWjntEOcdYrTfbGfHNZVJ\&ust=1717532527453000\&source=images\&cd=vfe\&opi=89978449\&ved=0CBIQjRxqFwoTCICKvrOhwIYDFQAAAAAdAAAAABAE) **驴C贸mo funciona?** Creas tu archivo **.env** y **guardas tus variables** de entorno all铆. **.env** ```js WEB="whatever.com" ```Dejas tus scripts como lo dejar铆as normalmente, pero sin tener que importar nada, as铆: **file.js** ```js let web = process.env.WEB console.log("Tu web: " + web) ```La **novedad** est谩 en que al **correr tu script** debemos pasar una **bandera** para poder **apuntar al fichero** donde tenemos nuestras **variables**, de tal manera: `node --env-file .env entorno.js` **驴Qu茅 hay de nuevo?** El **problema** que se ten铆a con esta **bandera** era que siempre se **apuntaba hacia el mismo fichero**, entonces puede ser de que tengamos **diferentes ficheros**, as铆 que entre las novedades de la **versi贸n 20.12** de **Node.js** podemos descartar el uso de la bandera `--env-file` y llamar nuestro script normalmente `node file.js`. La nueva funci贸n trabaja de la siguiente manera. **.env** ```js WEB="whatever.com" ```**file.js** ```js process.loadEnvFile() // nueva funcionalidad let web = process.env.WEB console.log("Tu web: " + web) ```Llamamos a `process.loadEnvFile()` dentro de tu script, el cual va a llamar por defecto al archivo **.env** que tienes en la **ra铆z de tu directorio**, ya si quieres **agregar un fichero diferente** solo deber铆as de **agregarlo** dentro de los par茅ntesis (). **Casos de uso** Si vas a utilizar un solo fichero viene muy bien el uso de la bandera, pero si vas a trabajar con varios ficheros viene muy bien utilizar esta nueva utilidad.
**VARIABLES DE ENTORNO** *Las **variables** de **entorno** en* **Node.js** *son una **herramienta** **crucial** para la **configuraci贸n** de **aplicaciones**, permitiendo la **separaci贸n** de los **datos** de **configuraci贸n** del **c贸digo** **fuente**. Estas **variables** se **utilizan** para **almacenar informaci贸n sensible** y **espec铆fica** del **entorno**, como **claves** de* **APIs***, **cadenas** de **conexi贸n** a **bases** de **datos** y **configuraciones** **espec铆ficas** del **entorno** de **desarrollo**, **pruebas** o **producci贸n**.* **Node.js** *permite **acceder** a estas **variables a trav茅s** del **objeto*** **process.env***, **proporcionando** una manera **sencilla** y **segura** de **manejar** **diferentes** **configuraciones sin necesidad** de **modificar** el **c贸digo**. Esta **pr谩ctica no solo mejora** la **seguridad**, **sino** que **tambi茅n** **facilita** el **despliegue** y la **portabilidad** de las **aplicaciones**.*

C贸digo con sintax铆s moderna:

let nombre = process.env.NOMBRE ?? 'Miguel'
let web = process.env.WEB ?? 'Google'

console.log(`hola ${nombre}`);
console.log(`Mi web es ${web}`);

Las variables de entorno son variables que se crean fuera del programa a ejecutar. La forma de acceder a ellas es como se muestra en el c贸digo de ejemplo. 驴Por qu茅 es importante usar variables de entorno? Por ejemplo cuando tenemos que pasar informaci贸n delicada, como usuarios y contrase帽as, acceso a APIS, etc, es mejor que esta informaci贸n no est茅 dentro del c贸digo, si no en una zona fuera de este. Desde siempre las variables de entorno se declaran en may煤sculas y si requiere dos nombres para esto es usar谩 '\_' para separarlos. Ejemplo: ````js // process.env.NOMBREVARIABLEENTORNO --> es la forma de llamar a la variable de entorno. let nombre = process.env.NOMBRE || 'Sin nombre'; //En javascript se usa || para dar la opci贸n de que si no existe la variable tome un valor por defecto. let web = process.env.MI_WEB || 'No tengo web'; console.log('Hola ' + nombre); console.log('Esta es mi web ' + web); ``` ````Como se pasan las variables de entorno: ```js $> NOMBRE=Antonio MI_WEB=atigra.es node nombrearchivo.js ```
no me funciona la variable de entorno ![](https://static.platzi.com/media/user_upload/image-259c4b4e-0410-4264-ab33-dda779087242.jpg)
Se puede activar el auto Guardado desde VSC![](https://static.platzi.com/media/user_upload/VSCode%20c%C3%B3mo%20activar%20el%20auto%20guardado-13dccda8-32c2-48dc-a38f-fee16cf04633.jpg)
let nombre = process.argv\[2] console.log("Hola " + nombre); $NOMBRE="OSCAR" node variablesEntorno $NOMBRE yo tuve que modificar el process y tomar el argv\[2] que era el valor que le pasaba como variable
Si tu terminal no es Linux debes inicializar las variables de la siguiente manera: $env:NOMBRE="Carlos" \[SIGUIENTE LINEA O ENTER] $env:WEB="estaesmyweb.com" \[SIGUIENTE LINEA O ENTER] node conceptos/entorno.js Me gui茅 en el aporte de Blesy Angulo, hubiese sido muy dif铆cil avanzar sin ese aporte

Sobre las variables de entorno 馃憖

Desde la versi贸n 20.6.0 de Node, ya no tendremos que usar paquetes como dotenv para declarar nuestras variables de entorno y acceder a ellla en nuestro scripts!

Si usan bash deben exportar la variable antes y luego ejecutar el programa![](https://static.platzi.com/media/user_upload/image-b7e509bf-67d5-47b8-8a27-d45faf855606.jpg)
Hola buen dia, al momento de ejecutar me sale el siguiente error, he ralizado la configuracion de variables de entorno en windows pensando que era eso pero no me funciona ![](https://static.platzi.com/media/user_upload/image-18000c14-6cd4-4718-a0fc-0616e574ada9.jpg) Agradezco me puedan ayudar con la solucion a este problema gracias

as铆 va mi archivo: entorno.js

require('dotenv').config()
let nombre = process.env.NOMBRE;
console.log("Hello "+nombre); //

antes de ejecutar con el comando:

node entorno.js

se debe definir

el archivo .env

En mi caso, fue as铆:

NOMBRE=Universo