Cómo escribir y ejecutar tu primera aplicación en Node.js

Introducción

Node.js es un popular entorno de ejecución de código abierto que permite ejecutar JavaScript fuera del navegador mediante el motor V8 de JavaScript, el mismo que se utiliza para ejecutar JavaScript en el navegador web Google Chrome. Node Runtime se utiliza habitualmente para crear herramientas de línea de comandos y servidores web.

Aprender Node.js te permite escribir tu código front-end y back-end en el mismo lenguaje. Usar JavaScript en toda la pila puede ayudar a reducir el tiempo de cambio de contexto, y las bibliotecas se comparten más fácilmente entre tu servidor back-end y los proyectos front-end.

Además, gracias a su compatibilidad con la ejecución asíncrona, Node.js destaca en tareas con uso intensivo de E/S, lo que lo hace ideal para la web. Las aplicaciones en tiempo real, como las de streaming de vídeo o las que envían y reciben datos constantemente, pueden ejecutarse con mayor eficiencia cuando se escriben en Node.js.

En este tutorial, crearás tu primera aplicación con el entorno de ejecución de Node.js. Aprenderás algunos conceptos específicos de Node y te familiarizarás con la creación de una aplicación que ayude a los usuarios a consultar las variables de entorno de su sistema. Para ello, aprenderás a generar cadenas de texto en la consola, recibir entradas del usuario y acceder a las variables de entorno.

Requisitos previos

Para completar este tutorial, necesitarás:

• Node.js está instalado en tu equipo de desarrollo. Este tutorial usa la versión 10.16.0 de Node.js. Para instalarlo en macOS o Ubuntu 18.04, sigue los pasos de "Cómo instalar Node.js y crear un entorno de desarrollo local en macOS" o la sección "Instalar usando un PPA" de "Cómo instalar Node.js en Ubuntu 18.04".
• Conocimientos básicos de JavaScript que puedes encontrar aquí: Cómo codificar en JavaScript.

Paso 1 – Salida a la consola

Para escribir un programa que diga “¡Hola, mundo!”, abra un editor de texto de línea de comandos como nano y cree un nuevo archivo:

nano hello.js

Cuando se abra el editor de texto, ingrese el siguiente código:

console.log("Hello World");

El objeto consola de Node.js proporciona métodos sencillos para escribir en la salida estándar (stdout), la salida estándar (stderr) o cualquier otro flujo de Node.js, que en la mayoría de los casos es la línea de comandos. El método de registro imprime en la salida estándar (stdout), por lo que puede verlo en la consola.

En el contexto de Node.js, los streams son objetos que pueden recibir datos, como el stream de salida estándar (stdout), o que pueden generar datos, como un socket de red o un archivo. En el caso de los streams de salida estándar (stdout) y de salida estándar (stderr), cualquier dato que se les envíe se muestra en la consola. Una de las características importantes de los streams es su fácil redirección, lo que permite, por ejemplo, redirigir la salida de un programa a un archivo.

Guarde y salga de nano presionando CTRL+X, cuando se le solicite guardar el archivo, presione Y. Ahora su programa está listo para ejecutarse.

Paso 2 – Ejecutar el programa

Para ejecutar este programa, utilice el comando node de la siguiente manera:

node hello.js

El programa hello.js se ejecuta y muestra la siguiente salida:

Output
Hello World

El intérprete de Node.js leyó el archivo y ejecutó console.log ("Hola Mundo") llamando al método log del objeto global console. La cadena "Hola Mundo" se pasó como argumento a la función log.

Aunque las comillas son necesarias en el código para indicar que el texto es una cadena, no se imprimen en la pantalla.

Habiendo confirmado que el programa funciona, hagámoslo más interactivo.

Paso 3: Obtener la entrada del usuario a través de argumentos de la línea de comandos

Cada vez que se ejecuta "¡Hola, mundo!" en Node.js, el programa produce la misma salida. Para que el programa sea más dinámico, tomaremos la entrada del usuario y la mostraremos en pantalla.

Las herramientas de línea de comandos suelen aceptar diversos argumentos que modifican su comportamiento. Por ejemplo, al ejecutar node con el argumento –version, se imprimirá la versión instalada en lugar de ejecutar el intérprete. En este punto, ha aceptado su código mediante argumentos de línea de comandos.

Crea un nuevo archivo arguments.js con nano:

nano arguments.js

Introduzca el siguiente código:

console.log(process.argv);

El objeto de proceso es un objeto global de Node.js que contiene funciones y datos relacionados con el proceso de Node.js en ejecución. La propiedad argv es una matriz de cadenas que contiene todos los argumentos de la línea de comandos proporcionados a un programa.

Guarde y salga de nano escribiendo CTRL+X, presione Y cuando se le solicite para guardar el archivo.

Ahora, cuando ejecuta este programa, proporciona un argumento de línea de comando como este:

node arguments.js hello world

El resultado es el siguiente:

Output
[ '/usr/bin/node',
'/home/sammy/first-program/arguments.js',
'hello',
'world' ]

El primer argumento del array process.argv siempre es la ubicación del binario de Node.js que ejecuta el programa. El segundo argumento siempre es la ubicación del archivo que se está ejecutando. Los demás argumentos son los que el usuario introdujo; en este caso: "Hola mundo".

Nos interesan más los argumentos introducidos por el usuario, no los predeterminados de Node.js. Abra el archivo arguments.js para editarlo:

nano arguments.js

Cambie console.log(process.arg); por lo siguiente:

console.log(process.argv.slice(2));

Dado que argv es un array, puedes usar el método slice integrado de JavaScript, que devuelve una colección de elementos. Al pasar la función slice con 2 como argumento, obtienes todos los elementos de argv después del segundo elemento. Es decir, los argumentos introducidos por el usuario.

Ejecute el programa nuevamente con el comando node y los mismos argumentos que la última vez:

node arguments.js hello world

Ahora, el resultado es el siguiente:

Output
[ 'hello', 'world' ]

Ahora que puede recopilar información del usuario, recopilemos información del entorno de la aplicación.

Paso 4: Acceso a las variables de entorno

Las variables de entorno son datos clave-valor que se almacenan fuera de la aplicación y son proporcionados por el sistema operativo. Normalmente, las configura el sistema o el usuario y están disponibles para todos los procesos en ejecución con fines de configuración o estado. Se puede acceder a ellas mediante el objeto de proceso Node.

Utilice nano para crear un nuevo archivo de entorno.

nano environment.js

Añade el siguiente código:

console.log(process.env);

El objeto env almacena todas las variables de entorno que están disponibles cuando se ejecuta una aplicación Node.js.

Guarde y salga como antes y ejecute el archivo environment.js con el comando node.

node environment.js

Después de ejecutar el programa, debería ver un resultado similar al siguiente:

Output
{ SHELL: '/bin/bash',
SESSION_MANAGER:
'local/digitalocean:@/tmp/.ICE-unix/1003,unix/digitalocean:/tmp/.ICE-unix/1003',
COLORTERM: 'truecolor',
SSH_AUTH_SOCK: '/run/user/1000/keyring/ssh',
XMODIFIERS: '@im=ibus',
DESKTOP_SESSION: 'ubuntu',
SSH_AGENT_PID: '1150',
PWD: '/home/sammy/first-program',
LOGNAME: 'sammy',
GPG_AGENT_INFO: '/run/user/1000/gnupg/S.gpg-agent:0:1',
GJS_DEBUG_TOPICS: 'JS ERROR;JS LOG',
WINDOWPATH: '2',
HOME: '/home/sammy',
USERNAME: 'sammy',
IM_CONFIG_PHASE: '2',
LANG: 'en_US.UTF-8',
VTE_VERSION: '5601',
CLUTTER_IM_MODULE: 'xim',
GJS_DEBUG_OUTPUT: 'stderr',
LESSCLOSE: '/usr/bin/lesspipe %s %s',
TERM: 'xterm-256color',
LESSOPEN: '| /usr/bin/lesspipe %s',
USER: 'sammy',
DISPLAY: ':0',
SHLVL: '1',
PATH:
'/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin',
DBUS_SESSION_BUS_ADDRESS: 'unix:path=/run/user/1000/bus',
_: '/usr/bin/node',
OLDPWD: '/home/sammy' }

Tenga en cuenta que muchas de las variables de entorno que ve dependen de la configuración y los ajustes de su sistema, y el resultado puede ser significativamente diferente al que ve aquí. En lugar de ver una larga lista de variables de entorno, le recomendamos recuperar una específica.

Paso 5: Acceso a una variable de entorno específica

En este paso, verá las variables de entorno y sus valores utilizando el objeto global process.env e imprimirá sus valores en la consola.

El objeto process.env es una asignación simple entre los nombres de las variables de entorno y sus valores, almacenados como cadenas. Como todos los objetos en JavaScript, se accede a una propiedad haciendo referencia a su nombre entre paréntesis.

Abra el archivo environment.js para editarlo:

nano environment.js

Cambie console.log(process.env); a:

console.log(process.env["HOME"]);

Guarde el archivo y salga. Ahora ejecute la aplicación environment.js:

node environment.js

Ahora la salida se ve así:

Output
/home/sammy

En lugar de imprimir el objeto completo, ahora solo imprime la propiedad HOME de process.env, que almacena el valor de la variable de entorno $HOME.

Nuevamente, tenga en cuenta que la salida de este código probablemente será diferente a la que ve aquí, ya que es específica de su sistema. Ahora que puede especificar la variable de entorno que desea recuperar, puede mejorar su aplicación preguntando al usuario por la variable que desea ver.

Paso 6: recuperar un argumento en respuesta a la entrada del usuario

A continuación, utilizará la capacidad de leer argumentos de la línea de comandos y variables de entorno para crear una herramienta de línea de comandos que imprima el valor de una variable de entorno en la pantalla.

Utilice nano para crear un nuevo archivo echo.js:

nano echo.js

Añade el siguiente código:

const args = process.argv.slice(2);
console.log(process.env[args[0]]);

La primera línea de echo.js almacena todos los argumentos de la línea de comandos proporcionados por el usuario en una variable constante llamada args. La segunda línea imprime la variable de entorno almacenada en el primer elemento de args. Es decir, el primer argumento de la línea de comandos proporcionado por el usuario.

Guarde y salga de nano, luego ejecute el programa de la siguiente manera:

node echo.js HOME

Ahora la salida será:

Output
/home/sammy

El argumento HOME se almacenó en la matriz args, que luego se utilizó para encontrar su valor en el entorno a través del objeto process.env.

Ahora puede acceder al valor de cualquier variable de entorno de su sistema. Para verificarlo, consulte las siguientes variables: PWD, USER, PATH.

Está bien recuperar variables individuales, pero es mejor permitir que el usuario especifique la cantidad de variables que desea.

Paso 7: Ver múltiples variables de entorno

Actualmente, el programa solo puede verificar una variable de entorno a la vez. Sería útil si pudiéramos aceptar múltiples argumentos de línea de comandos y obtener su valor correspondiente en el entorno. Use nano para editar echo.js:

nano echo.js

Edite el archivo para que contenga el siguiente código:

const args = process.argv.slice(2);
args.forEach(arg => {
console.log(process.env[arg]);
});

El método forEach es un método estándar de JavaScript para todos los objetos de matriz. Acepta una función de devolución de llamada que se utiliza al iterar sobre cada elemento de la matriz. Se utiliza forEach en la matriz args y se proporciona una función de devolución de llamada que imprime el valor del argumento actual en el entorno.

Guarde y salga del archivo. Ahora vuelva a ejecutar el programa con dos argumentos:

node echo.js HOME PWD

Verá el siguiente resultado:

[secondary_label Output] 
/home/sammy
/home/sammy/first-program

La función forEach garantiza que cada argumento de la línea de comando se imprima en la matriz args.

Ahora tienes una forma de recuperar las variables que solicita el usuario, pero aún necesitamos manejar casos en los que el usuario ingresa datos incorrectos.

Paso 8: Manejo de entradas no especificadas

Para ver qué sucede si le da al programa un argumento que no es una variable de entorno válida, ejecute lo siguiente:

node echo.js HOME PWD NOT_DEFINED

La salida será similar a la siguiente figura:

[secondary_label Output] 
/home/sammy
/home/sammy/first-program
undefined

Las dos primeras líneas se imprimen como se esperaba, y la última línea simplemente no está definida. En JavaScript, un valor no definido significa que a una variable o propiedad no se le ha asignado un valor. Dado que NOT_DEFINED no es una variable de entorno válida, se muestra como no definida.

Si el argumento de la línea de comando del usuario no se encuentra en el entorno, sería más útil para el usuario ver un mensaje de error.

Abra echo.js para editarlo:

nano echo.js

Edite echo.js para que contenga el siguiente código:

const args = process.argv.slice(2);
args.forEach(arg => {
let envVar = process.env[arg];
if (envVar === undefined) {
console.error(`Could not find "${arg}" in environment`);
} else {
console.log(envVar);
}
});

Aquí, ha modificado la función de devolución de llamada proporcionada a forEach para hacer lo siguiente:

1. Obtenga el valor de los argumentos de la línea de comando en el entorno y almacénelo en una variable env Var.
2. Compruebe si el valor de envVar no está definido.
3. Si envVar no está definido, imprimimos un mensaje útil indicando que no se encontró.
4. Si se encuentra la variable de entorno, imprimimos su valor.

Ahora ejecute el siguiente comando una vez más:

node echo.js HOME PWD NOT_DEFINED

Esta vez el resultado será:

[secondary_label Output] 
/home/sammy
/home/sammy/first-program
Could not find "NOT_DEFINED" in environment

Ahora, cuando proporcione un argumento de línea de comando que no sea una variable de entorno, recibirá un mensaje de error claro que lo indica.

Resultado

Su primer programa mostraba “Hola mundo” en la pantalla y ahora ha escrito una herramienta de línea de comandos Node.js que lee los argumentos del usuario para mostrar las variables de entorno.

Si desea profundizar en este tema, puede modificar aún más el comportamiento de este programa. Por ejemplo, podría querer validar los argumentos de la línea de comandos antes de imprimir. Si un argumento no está definido, puede devolver un error y el usuario solo recibirá la salida si todos los argumentos son variables de entorno válidas.