---
# System prepended metadata

title: Node.js | Intro e Instalación

---

![](https://i.imgur.com/ld6aL74.png =200x)

# Node.js | Intro e Instalación

## ¿Qué es Node.js?

Node.js (a veces llamado simplemente _Node_ para abreviar) es un **runtime** de JavaScript desarrollado por Ryan Dahl, mientras trabajaba en Joyent. En resumen, Dahl creó Node debido a las [limitaciones sincrónicas de los marcos web actuales](https://www.infoq.com/interviews/node-ryan-dahl). Node nos ha permitido ejecutar JavaScript en cualquier lugar, incluidos servidores web y robots.

En el pasado, el único entorno de ejecución para JavaScript era el navegador. Chrome, Safari e Internet Explorer tenían sus propios tiempos de ejecución de JavaScript, pero *no podíamos* ejecutar JavaScript en nuestras computadoras.

Dahl cambió esto extrayendo el "entorno de ejecución V8" de código abierto de Chrome y creando una implementación para servidores.

### Entorno de ejecución

Un **entorno de ejecución** es un entorno que incluye todas las herramientas y características necesarias para ejecutar un programa específico, o en el caso de Node.js, un lenguaje de programación.

La computadora es tonta. Realmente solo entiende el lenguaje de máquina, 1 y 0, que (lo más probable) no puede leer. La computadora no comprende JavaScript, Python, Ruby, Java y la mayoría de los otros lenguajes.

Estos idiomas deben traducirse a [bytecode](https://en.wikipedia.org/wiki/Bytecode), que luego se convierte en código de máquina y el sistema operativo host, o un intérprete, lo lee, todo ello teniendo en cuenta cosas como [gestión de memoria](https://en.wikipedia.org/wiki/Memory_management), acceder al sistema de archivos o utilizar funciones nativas del sistema operativo.

¡Eso es exactamente lo que hace Node.js! Traduce un programa JavaScript en código de bytes para que lo ejecute una computadora.

En resumen, JavaScript anteriormente solo se podía ejecutar en el navegador. ¡Node.js nos permite ejecutarlo en cualquier lugar!

### ¿Que NO es Node.js?

Los siguientes son nombres erróneos y conceptos erróneos comunes relacionados con Node:

- ***No*** es un framework (aunque hay frameworks construidos sobre Node.js).
- ***No*** es un lenguaje de programación (el lenguaje sigue siendo JavaScript).

## ¿Por qué Node.js?

Debido a que Node usa el modelo *impulsado por eventos* y *asincrónico* de JavaScript, sobresale con ciertas aplicaciones web, como aplicaciones de chat y aplicaciones que necesitan funciones de actualización en vivo en tiempo real.

Otro beneficio (subjetivo y discutible) es que el lenguaje JavaScript es universal. En teoría, la curva de aprendizaje puede ser menor para aquellos que ya están familiarizados con JavaScript front-end.

Relacionado con eso, está el concepto de compartir código en su front-end y back-end porque están escritos en el mismo idioma, aunque muchos están de acuerdo en que el código back-end es muy diferente, incluso si es el mismo idioma.

Además, Node tiene un ecosistema fuerte y en crecimiento. Esto incluye paquetes creados por la comunidad y desarrollo continuo de código abierto en el tiempo de ejecución.

Dado que Node utiliza [Google's V8](https://developers.google.com/v8/) entre bastidores, Node también se beneficia de la competencia entre navegadores. A medida que Google mejora V8 para competir con [Mozilla's SpiderMonkey](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey), [Microsoft's Chakra](https://github.com/Microsoft/ ChakraCore) y otros, Node también obtiene los beneficios de esas mejoras.

## Instalar Node

Instalar Node es relativamente fácil. Podemos usar `brew` o` apt-get` para instalar Node en Mac o Linux, pero también queremos mantener Node actualizado.

Además, algunos proyectos pueden usar una versión de Node diferente a la suya. Esto puede convertirse en una molestia, así que lo que sugerimos es instalar [Node Version Manager(nvm)](https://github.com/creationix/nvm).

:::warning
Otra alternativa buena es el [Paquete N](https://www.npmjs.com/package/n).
:::


NVM le permite elegir qué versión de Node usar, instalar nuevas versiones y más.

### Instalar NVM

Primero, tenemos que instalar algunos requisitos previos.

#### Mac

En la terminal:

```
$ xcode-select --install
```

#### Ubuntu

En la terminal:

```
$ apt-get update
$ apt-get install build-essential libssl-dev
```

Ahora podemos instalar NVM

```
$ curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.32.1/install.sh | bash
```

Pruebe para ver si se ha instalado correctamente con:

```
$ nvm --version
0.32.1
```

En el momento de escribir este artículo, la versión más reciente de Node es 13.13.0. Instalemos y usemos esto con NVM:

```
$ nvm install 13.13.0
```

Para actualizar la configuración de ZSH, ejecute lo siguiente:

```
$ nvm use 13.13.0
```

Y para probar para asegurarse de que la instalación esté completa:

```
node --version
```

## Nuestro uso de NodeJS

En este curso, usaremos Node al principio para aprender algunas características nuevas de JavaScript y escribir algunos algoritmos de JavaScript más complejos.

Más adelante, usaremos Node como servidor web y un marco web construido sobre Node (Express).

## Primer código

Creamos un archivo nuevo que se llame `test.js`.

En el archivo, agregamos el siguiente código:

```javascript
console.log("Hello Node");
```

En la terminal **terminal**:

```
$ node test.js
Hello Node
```

Podemos escribir cualquier código JavaScript que queramos en Node, pero debemos tener en cuenta *no hay DOM*.

¡Listo! Estamos listos y funcionando con Node.


## npm & modules


### Intro

**npm** es un administrador de paquetes para Node. Esto significa que nosotros y otros programadores pueden compartir el código JavaScript de forma fácil, utilizando una herramienta de línea de comandos.

npm tiene uno de los ecosistemas más sólidos para paquetes externos. En el momento de redactar este artículo, hay más de 35.000 módulos npm disponibles para descargar.

**Los módulos** son paquetes de código reutilizable que se empaquetan con cualquiera de los códigos del que dependen (dependencias). Los beneficios de los módulos son infinitos y los discutiremos en breve.

### ¿Qué es un administrador de paquetes, y por qué??

#### Los paquetes para proyectos son difíciles de administrar

Cuando trabajas en tu propio código entre un equipo, es *realmente* difícil mantener cosas como las versiones y las dependencias en orden. Digamos que vos y Francisco están trabajando juntos en un proyecto. Bob está usando la versión `1.2` de un módulo. Vos estás usando la versión `1.8`.

El problema aquí es que el código entre esas dos versiones puede haber cambiado drásticamente. Ambos van a implementar una nueva característica usando este paquete, y ahora tu versión funciona en tu computadora, pero no en la de Francisco.

Ahora imagina que hay otros 100 Franciscos en tu equipo. Cuando ese paquete se actualiza, todos tienen que actualizar su versión o tendrán problemas.

¡Eso es una pesadilla! Pero, ¡para eso existen los administradores de paquetes! 

En breve veremos cómo npm resuelve este problema.

#### Fomenta los buenos principios de desarrollo de software y el intercambio de código.

Digamos que vos como desarrollador de software junior comenzás a trabajar en Megacorp Software.

En tu primer día, el desarrollador senior te sienta y te pide que le ayude a desarrollar su función de carrito de compras. Te piden que escribas la lógica empresarial para calcular los precios de envío y los impuestos para su nueva sección de deportes.

Te sientas durante horas, investigando la logística, las compañías navieras y las tasas impositivas de cientos de ciudades de todo el mundo.

Acá es cuando te das cuenta, "Esta funcionalidad ya existe en alguna parte. Hemos hecho *todo* esto en el carrito de compras de nuestra sección de ropa".

Vos, como desarrollador de software profesional, copias y pega *todo* el código del carrito de la compra de ropa en el carrito de la compra deportiva, haciendo un uso intensivo de la función de buscar y reemplazar.

Al día siguiente, el desarrollador senior te pide que cree *otro* carrito de compras, esta vez para alimentos. ¿Copiar y pegar el código de nuevo? ¡No!

Toda esta funcionalidad se puede extraer en módulos y compartir en su base de código. La lógica para calcular impuestos, logística, envío, ¡todos podrían ser módulos separados que todos en la empresa comparten!

La extracción de código en módulos no solo le ahorra tiempo, sino que también es un buen principio de desarrollo de software y le ahorra tiempo y dinero a la empresa.


![](https://i.imgur.com/tMj7JpC.gif)

#### Paquetes escritos por otros

Como mencionamos anteriormente, **npm** tiene miles de módulos disponibles para su uso. Estos módulos incluyen funciones como colorear texto en la terminal, tomar entradas de línea de comandos, hacer bromas de Chuck Norris e incluso frameworks web completos.

Esto hace que no tengas que reinventar la rueda con cada nuevo proyecto. Echaremos un vistazo a algunos de los módulos más importantes durante el curso

## Instalación

Si instalaste Node, es probable que ya tengas instalado npm.

Probamos esto ejecutando el siguiente comando en la terminal:

```bash=
$ npm --version
```

Si recibís un número de versión, ¡está listo!

## Instalación de paquetes

Para instalar paquetes para usar en nuestro programa, primero debemos definir nuestro **archivo de manifiesto**. Un _archivo de manifiesto_ es un archivo que enumera todos los paquetes de los que depende nuestro programa para funcionar. Con **npm**, este archivo se llamará `package.json`.

Este archivo definirá todos nuestros paquetes de proyectos y dependencias.

Ejecute los siguientes comandos en su terminal:

```bash=
$ mkdir npm-getting-started
$ cd npm-getting-started
$ npm init
```

Si observa, esto creó un archivo llamado `package.json`. Este es un archivo con formato JSON que especifica todos los módulos que usaremos en el proyecto.

¡Instalemos nuestro primer módulo!

```bash
$ npm install --save chalk
```

`npm install` va a los servidores npm y toma un paquete llamado "chalk". `--save` agrega esto como una dependencia a nuestro package.json.

Además, hemos creado una carpeta `node_modules`. Aquí es donde se almacena el código real para el módulo `chalk`.

¡Vamos a usarlo!

```bash=
$ touch index.js
$ code index.js
```

Y luego dentro de `index.js`:

```javascript
var chalk = require('chalk');

console.log(chalk.blue('Hello, npm!'));
```

En primer lugar, "requerimos" el módulo y lo asignamos a una variable.

Entonces, podemos invocar esta variable y su función adjunta "blue".

```
$ node index.js
Hello npm
```

Puedes ver todas las funciones que Chalk pone a su disposición visitando [su página de documentación](https://www.npmjs.com/package/chalk). Un buen paquete tiene buena documentación para que la gente aprenda a usarlo.

Chalk es genial, pero es solo uno de los muchos paquetes `npm`.

:::danger
:bomb: **Nunca hagas commit de`node_modules` git**. Va a hacer que el respositorio sea muy pesado!
:::

Si solo subes el `package.json`, cualquier usuario va a poder replicar tu `node_modules` corriendo `npm install`.


## Recursos Extra

- [Getting the best out of NPM](https://jsblog.insiderattack.net/getting-the-best-out-of-npm-b73d4a8fbf29#.hehmw1xun) - More advanced NPM concepts
