Para ingresar las variables con PowerShell primero hay que definirlas escribiendo:
$env:NOMBRE="Carlos"
Una vez definido ejecutan el comando
node conceptos/entorno.js
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
Crea una cuenta o inicia sesión
¡Continúa aprendiendo sin ningún costo! Únete y comienza a potenciar tu carrera
Aportes 160
Preguntas 30
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=“tuNombre” ; node entorno.js
( de ese modo es posible enviar los 2 comandos a las vez)
----- usar CMD o cambiar Visual a CMD
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
Les dejo mis apuntes usando Notion de esta clase ^^
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)
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
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 😄.
.
npm install dotenv
.
NAME=Juan
WEB=https://github.com/Juangr1803/Fundamentos-nodejs
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 “process.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 “”.
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);
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?
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
Asi la ejecute con powershell
$env:NOMBRE=“julian”; 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 || ‘sin 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 ‘process.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
[]
MAC Agosto 2023
<
Definir variable
export MI_VARIABLE=mi_valor
Para ejecutar:
echo $MI_VARIABLE
(url)
Si usan CMD es:
set NOMBRE=tuNombre
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 “require”, 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.
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
process.env.NOMBRE_VARIABLE_DE_ENTORNO
.
¿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:
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 || “Sin nombre”;
console.log('Hola '+ nombre);
//NOMBRE=Juan node first.js - Bash
//POwershell $env:NOMBRE=“Carlos”
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’s, tokens de API’s, 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:
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.
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.
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
LINUX:
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);
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 establecer un valor a la variable NOMBRE desde la terminal se puede hacer de la siguiente forma
Set NOMBRE = Nietsnie
node conceptos/entorno.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}`)
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"
Aunque puedo definir la variable de entorno me sigue saliendo undefained para solucionarlo tuve que agregarla al entorno global usando export
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>
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.
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.
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}`);
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?