JavaScript en el

lado servidor:
NodeJS
Índice
| JavaScript del lado servidor 3

1.1 | Instalación y utilización 4

Instalación 4
1
Utilización 5

1.2 | Creación de un servidor HTTP 6

Manipulación de peticiones 8

¿Qué es el módulo express? 8

Instalación 8

Creando rutas 9

Recibiendo parámetros 10

Recibiendo POST 10

Usando expresiones regulares como ruta 11

1.3 | Módulos principales 13

 JavaScript en el lado servidor: NodeJS | TELEFÓNICA //

1. JavaScript del lado servidor

Las primeras evoluciones de JavaScript vivían en los navegadores. Pero esto
es sólo un contexto. Debemos tener claro que JavaScript es un lenguaje
“completo”: Se utiliza en muchos otros contextos. Node.js realmente es
sólo otro contexto: te permite ejecutar e interpretar código JavaScript en el
backend, es decir, fuera del navegador.

Para utilizar el código JavaScript en el backend, éste necesita

ser interpretado y, bueno, ejecutado. Esto es lo que Node.js Por tanto, Node.js es ciertamente dos cosas: una librería y
un entorno de ejecución.
hace, con el uso de la Máquina Virtual V8 de Google, el
mismo entorno de ejecución para JavaScript que el Para hacer uso de éstas (la librería y el entorno), necesitas
navegador de Google, Chrome, usa. instalar Node.js en tu equipo.
Aparte, Node.js aporta muchos módulos útiles, de manera
que no tienes que escribir todo de cero, como por ejemplo,
algo que ponga un String a la consola.
 JavaScript en el lado servidor: NodeJS |

1.1 | Instalación y utilización

INSTALACIÓN

Entrar en NodeJS (https://nodejs.org/en/

download/) y descargar el ejecutable para
instalar NodeJS según nuestro SO.

La instalación es muy sencilla y una

vez instalado (a partir de nuestro
ejecutable) ya podemos ejecutar NodeJs
para que aparezca una consola de
comandos.
 JavaScript en el lado servidor: NodeJS | TELEFÓNICA //

UTILIZACIÓN

Vamos, pues, a realizar nuestra primera aplicación Node.js: “Hola

Mundo”.

Podemos escribirla con cualquier editor de textos.

Creamos un archivo llamado holamundo.js y lo rellenamos con

este código:

console.log(“Hola Mundo”);
Salvamos el archivo, y lo ejecutamos a través de Node.js (en
Se puede desarrollar en cualquier IDE de desarrollo que permita consola dentro de nuestro equipo):
escribir código JS de tal manera que podemos ejecutar un js
desde línea de comandos (se presupone un archivo js que
llamado helloworld.js)

node holamundo.js

Este debería devolver Hola Mundo en tu monitor.

 JavaScript en el lado servidor: NodeJS |

1.2 | Creación de un servidor HTTP

Aunque más adelante hablaremos de la introducción de módulos en NodeJS, es necesario
abordar un primer módulo imprescindible para la creación de un servidor de HTTP. Este es el
módulo http.

Aunque más adelante hablaremos de la introducción de módulos

Las claves se convierten a minúsculas. Los valores no se
en NodeJS, es necesario abordar un primer módulo
imprescindible para la creación de un servidor de HTTP. Este modifican.
es el módulo http.
Para soportar el espectro completo de las posibles aplicaciones
Para usar el servidor y el cliente HTTP se debe añadir HTTP, la API HTTP de Node es de muy bajo nivel. Se encarga
únicamente de manejar el stream y del parsing del mensaje.
require(‘http’).
Parsea el mensaje en sus cabeceras y body pero no parsea
las cabeceras o el body.
Las interfaces HTTP en Node están diseñadas para soportar muchas
de las características del protocolo que tradicionalmente han
sido
difíciles de usar. En particular, los mensajes grandes, seguramente CLIENT SERVER BUSINESS DATA LAYER
fragmentado. La interfaz se asegura de que las peticiones o LAYER
respuestas nunca se almacenen completamente en un búfer--se Mobile Browser
permite al usuario hacer stream de datos.
Database
Application
Las cabeceras de los mensajes HTTP se representan por un Server
objeto como este: Web Browser
Web
Server
File External System
{ ‘content-length’: ‘123’, ‘content-type’: ‘text/plain’, Application System

‘connection’: ‘keep-alive’, ‘accept’: ‘/’ }

 JavaScript en el lado servidor: NodeJS | TELEFÓNICA //

Como hemos comentado, para crear un

servidor HTTP en NodeJS necesitamos la
carga del módulo http pero, aparte,
podemos necesitar la carga de otros //Carga de los módulos requeridos para el programa var http = require(‘http’);
módulos de node como el de filesystem var fs = require(‘fs’); var url = require(‘url’);
//Creación del servidor
y el de url (ambos en el ejemplo inferior). http.createServer( function (request, response) {
El primero serviría para buscar en el // Cogemos el path que nos ha entrado por la request var pathname = url.parse(request.url).pathname;
sistema de ficheros la página a devolver
con la petición y el segundo para coger // Leemos el fichero requerido para que sea enviado fs.readFile(pathname.substr(1), function (err, data) {
if (err) {
la url del envío de nuestro cliente. console.log(err);
// Página no encontrada
// HTTP Status: 404 : NOT FOUND
// Content Type: text/plain
response.writeHead(404, {‘Content-Type’: ‘text/html’});
}else{
// Página encontrada
// HTTP Status: 200 : OK
// Content Type: text/plain
response.writeHead(200, {‘Content-Type’: ‘text/html’});

// Damos la respuesta a nuestra petición response.write(data.toString());

}
// Enviamos la respuesta response.end();
});
}).listen(8081);
 JavaScript en el lado servidor: NodeJS |

Una vez tengamos nuestro servidor lanzado vemos que lo hemos INSTALACIÓN
puesto a escuchar en el puerto 8081 por lo que un cliente desde
el navegador podría acceder a él de esta manera: Para instalar dicho módulo solo sería necesario escribir esta
línea desde consola de comandos:

http://127.0.0.1:8081/index.htm

$ npm install -g express

Esta petición se haría sobre localhost (127.0.0.1) al puerto 8081

y pidiendo la página index.html que se encontraría en los
Si escribimos la siguiente línea nos devolverá la versión de
recursos del servidor.
express que se ha descargado (en el ejemplo la 3.3.5):
MANIPULACIÓN DE PETICIONES

Para poder realizar la manipulación de peticiones es

necesario instalar el módulo de express en nuestra aplicación. Ahora$ que
express
ya --tenemos los paquetes que necesitamos,
podemos empezar a escribir nuestra aplicación. Creamos un
Pero, ¿para qué sirve este módulo y que es lo que nos ofrece? version 3.3.5
nuevo archivo llamado app.js en el directorio del proyecto, este
archivo será el que inicie el servidor. Empezamos, escribiendo
¿QUÉ ES EL MÓDULO EXPRESS?
las dependencias que necesitamos:
Express es un módulo de NodeJS que se puede instalar a través
de la herramienta npm.

En una definición exacta sería: el framework que se lanza sobre

un servidor http de NodeJS para manipular las rutas y dar
acceso de un modo sencillo al cliente para acceder al ciclo de vida
de la aplicación.
var express =
require(‘express’); var http =
require(‘http’);
 JavaScript en el lado servidor: NodeJS | TELEFÓNICA //

express es el framework, como ya hemos Por último creamos e iniciamos el servidor:

comentado. http es el módulo del servidor para

NodeJS.

Ahora creamos nuestra aplicación: http.createServer(app).listen(app.get(‘port’), function()

{ console.log(‘Express server listening on port ‘ + app.

var app = express(); get(‘port’));

});

Le indicamos a express en que puerto vamos a estar

escuchando: Ahora ya tenemos lo mínimo necesario para iniciar la aplicación.

CREANDO RUTAS

process.env.PORT
app.set(‘port’,esprocess.env.PORT
una variable de|| entorno,
3000); si no está Las rutas nos permiten direccionar peticiones a los
configurada para guardar el puerto en que debe correr la controladores correctos. Vamos a empezar agregando el código
aplicación, entonces toma el 3000. de un controlador para una ruta:
app.get(‘/’, function(request,
response) { response.send(‘¡Hola,
Express!’);
 JavaScript en el lado servidor: NodeJS |

Si corremos nuestra app en la consola (parados en directorio de RECIBIENDO POST

la aplicación) node app.js y vamos a “http://localhost:3000/” en
nuestro explorador de preferencia, debemos ver el mensaje “¡Hola, También podemos recibir requests de tipo POST de la
Express!” siguiente manera:

RECIBIENDO PARÁMETROS

Si queremos recibir algún parámetro en una ruta debemos app.post(‘/users’, function(request, response)
especificar en el String el nombre del parámetro son “:” { var username = request.body.username;
adelante:
response.send(‘¡Hola, ‘ + username + ‘!’);
});
app.get(‘/users/:userName’, function(request,
response)
{
var name = request.params.userName; Antes de correr este código debemos agregar bodyParser fuera
del método, porque express no parsea el cuerpo del request por
response.send(‘¡Hola, ‘ + name + ‘!’); defecto:
});

app.use(express.bodyParser());
Ahora si corremos la app y vamos a
“http://localhost:3000/users/ oscar” veremos que se despliega el
mensaje “¡Hola, Òscar!”.
 JavaScript en el lado servidor: NodeJS | TELEFÓNICA //

Ahora podemos hacerle un post desde cualquier app que nos

De esta misma manera también podemos recibir requests
permita hacerlo. Se puede utilizar una extensión de Chrome PUT y DELETE utilizando app.put() y app.delete()
llamada Postman, desde ahí le podemos enviar lo respectivamente.
siguiente a “http:// localhost:3000/users”:
USANDO EXPRESIONES REGULARES COMO RUTA

También podemos usar expresiones regulares como rutas,

por ejemplo, podríamos usar “/\/users\/(\d*)\/?(edit)?/” como
una ruta, especificando así que debe haber un dígito en el
medio y que la palabra “edit” es opcional.
POST /users HTTP/1.1 Host: localhost:3000 Authorization: ApiKey
appClient:xxxxxxxxxxxxxxxxxxxxxxxxxx
Cache-Control: no-cache
----WebKitFormBoundaryE19zNvXGzXaLvS5C
Content-Disposition: form-data; name=”username” oscar1234 app.get(/\/personal\/(\d*)\/?(edit)?/, function
----WebKitFormBoundaryE19zNvXGzXaLvS5C Y deberá retornar: (request, response) {
¡Hola, oscar1234! var message = ‘el perfil del empleado #’ +
request.params[0];
if (request.params[1] === ‘edit’)
{ message = ‘Editando ‘ + message;
} else {
message = ‘Viendo ‘ + message;
}
response.send(message);
});
 JavaScript en el lado servidor: NodeJS |

Si corremos la app y vamos a “http://

localhost:3000/personal/15” veremos
que se despliega el mensaje “Viendo el var express = require(‘express’); var http = require(‘http’);
perfil del empleado #15”, y si var app = express();
agregamos “/edit” al final veremos que // all environments
el mensaje cambia a “Editando el app.set(‘port’, process.env.PORT || 3000); app.use(express.bodyParser()); app.get(‘/’, f
perfil del empleado #15”. response.send(‘¡Hola, Express!’);
});
Luego de todos estos cambios tu
archivo app.js debe lucir así: app.post(‘/users’, function(request, response) { var username = request.body.username; r
});
app.get(/\/personal\/(\d*)\/?(edit)?/, function (request, response) { var message = ‘el
if (request.params[1] === ‘edit’) { message = ‘Editando ‘ + message;
} else {
message = ‘Viendo ‘ + message;
}
response.send(message);
});
http.createServer(app).listen(app.get(‘port’), function(){ console.log(‘Express server l
});
 JavaScript en el lado servidor: NodeJS | TELEFÓNICA //

1.3 | Módulos principales

NodeJS posee varios módulos compilados en binario. Estos módulos son descritos con más
detalle en las siguientes secciones del documento. Los módulos básicos son definidos en el
código fuente de NodeJS en la carpeta lib/.

Los módulos básicos tienen la preferencia de cargarse primero

si su identificador es pasado desde require(). Por ejemplo, • timers
require(‘http’) siempre devolverá lo construido en el módulo HTTP,
incluso si hay un fichero con ese nombre. Ofrece las funciones globales para el manejo de contadores
que realizarán la acción especificada pasado el tiempo que
se les programa. Debido a la cómo está diseñado Node,
A continuación vamos a pasar a reseñar algunos de los
relacionado con el bucle de eventos del que se hablará en
módulos más importantes que podemos agregar a nuestras
un futuro, no se puede garantizar que el tiempo de ejecución
aplicaciones de los centenares y centenares que hay. Como
de dicha acción sea exactamente el marcado, sino uno
nota, se debe comentar, que podemos construirnos nuestros
aproximado cercano a él, cuando el bucle esté en
propios módulos dentro de nuestra aplicación, con el objetivo
disposición de hacerlo.
de modularizar nuestro código.
• module
• console
Proporciona el sistema de módulos según impone
Marcado en el API como STDIO, ofrece el objeto console
CommonJS. Cada módulo que se carga o el propio programa,
para imprimir mensajes por la salida estándar: stdout y
está modelado según module, que se verá como una variable,
stderr. Los mensajes van desde los habituales info o log
module, dentro del mismo módulo. Con ella se tienen
hasta trazar la pila de errores con trace.
disponibles tanto el mecanismo de carga require() como
aquellas funciones y variables que exporta, en
module.exports, que destacan entre otras menos corrientes
que están a un nivel informativo: módulo que ha cargado el
actual (module.parent), módulos que carga el actual
(module.children)...
 JavaScript en el lado servidor: NodeJS |

• buffer • stream

Es el objeto por defecto en Node para el manejo de datos Interfaz abstracta que representa los flujos de caracteres de
binarios. Sin embargo, la introducción en JavaScript de los Unix
typedArrays desplazará a los Buffers como manera de de la cual muchas clases en Node heredan.
tratar esta clase de datos.
• crypto
Los módulos siguientes, listados por su identificador,
también forman parte del núcleo de Node, aunque no se Algoritmos y capacidades de cifrado para otros módulos y
cargan al inicio, pero se exponen a través del API: para el código de programa en general.

• util • tls

Conjunto de utilidades principalmente para saber de si un Comunicaciones cifradas en la capa de transporte con el
objeto es de tipo array, error, fecha, expresión protocolo TLS/SSL, que proporciona infraestructura de clave
regular...También ofrece un mecanismo para extender clases pública/privada.
de JavaScript a través de herencia: • string_decoder

Proporciona una manera de, a partir de un Buffer, obtener

• events cadenas de caracteres codificados en utf-8.
inherits(constructor, superConstructor);
Provee la fundamental clase EventEmitter de la que • fs
cualquier objeto que emite eventos en Node hereda. Si
alguna clase del código de un programa debe emitir Funciones para trabajar con el sistema de ficheros de la
eventos, ésta tiene que heredar de EventEmitter. manera que establece el estándar POSIX. Todos los métodos
permiten trabajar de forma asíncrona (el programa sigue
su curso y Node avisa cuando ha terminado la operación con
el fichero) o síncrona (la ejecución del programa se detiene
hasta que se haya completado la operación con el fichero).
 JavaScript en el lado servidor: NodeJS | TELEFÓNICA //

• path • https

Operaciones de manejo y transformación de la ruta de Versión del protocolo HTTP sobre conexiones seguras TLS/SSL.
archivos y directorios, a nivel de nombre, sin consultar el
sistema de ficheros. • url

• net Formateo y análisis de los campos de las URL.

Creación y manejo asíncrono de servidores y clientes, • querystrings

que implementan la interfaz Stream mencionada antes,
sobre el protocolo de transporte TCP. Utilidades para trabajar con las queries en el protocolo HTTP.
Una query son los parámetros que se envían al servidor
• dgram en las peticiones HTTP. Dependiendo del tipo de petición
(GET o POST), pueden formar parte de la URL por lo que
Creación y manejo asíncrono de datagramas sobre el deben codificarse o escaparse y concatenarse de una
protocolo transporte UDP. manera especial para que sean interpretadas como tal.
• dns • readline

Métodos para tratar con el protocolo DNS para la resolución Permite la lectura línea por línea de un Stream,
de nombres de dominio de Internet. especialmente indicado para el de la entrada estándar
(STDIN).
• http
• repl
Interfaz de bajo nivel, ya que sólo maneja los Streams y el
paso de mensajes, para la creación y uso de conexiones bajo Bucle de lectura y evaluación de la entrada estándar, para
el protocolo HTTP, tanto del lado del cliente como del incluir en programas que necesiten uno. Es exactamente
servidor. Diseñada para dar soporte hasta a las el mismo módulo que usa Node cuando se inicia sin
características más complejas del protocolo como chunk- argumentos, en el modo REPL comentado con
encoding. anterioridad.
 JavaScript en el lado servidor: NodeJS |

• vm • os

Compilación y ejecución bajo demanda de código. Acceso a información relativa al sistema operativo y
recursos hardware sobre los que corre Node.
• child_process
• _debugger
Creación de procesos hijos y comunicación y manejo de
su entrada, salida y error estándar con ellos de una Es el depurador de código que Node tiene incorporado, a
manera no bloqueante. través de la opción debug de la línea de comandos. En
realidad es un cliente que hace uso de las facilidades de
• assert
depuración que el intérprete de Javascript que utiliza
Funciones para la escritura de tests unitarios.
Node ofrece a través de una conexión TCP al puerto 5858.
• tty Por tanto, no es un módulo que se importe a través de
require() sino el modo de ejecución Debug del que se ha
Permite ajustar el modo de trabajo de la entrada estándar si hablado antes.
ésta es un terminal.
• cluster
• zlib
Creación y gestión de grupos de procesos Node trabajando
Compresión/descompresión de Streams con los algoritmos zlib en red para distribuir la carga en arquitecturas con
y gzip. Estos formatos se usan, por ejemplo, en el procesadores multi-core.
protocolo HTTP para comprimir los datos provenientes del
servidor. Es conveniente tener en cuenta que los procesos de
compresión y descompresión pueden ser muy costosos en
términos de memoria y consumo de CPU.
 JavaScript en el lado servidor: NodeJS | TELEFÓNICA //

• punycode • _linklist

Implementación del algoritmo Punycode, disponible a partir Implementa una lista doblemente enlazada. Esta estructura
de la versión 0.6.2, para uso del módulo url. El algoritmo de datos se emplea en timers.js, el módulo que provee
Punycode se emplea para convertir de una manera unívoca y funcionalidad de temporización.
reversible cadenas de caracteres Unicode a cadenas de
caracteres ASCII con caracteres compatibles en nombres Su función es encadenar temporizadores que tengan el
de red. mismo tiempo de espera, timeout. Esta es una manera muy
eficiente de manejar enormes cantidades de temporizadores
El propósito es que los nombres de dominio que se activan por inactividad, como los timeouts de los
internacionalizados (en inglés, IDNA), aquellos con caracteres sockets, en los que se reinicia el contador si se detecta
propios de un país, se transformen en cadenas soportadas actividad en él. Cuando esto ocurre, el temporizador, que
globalmente. está situado en la cabeza de la lista, se pone a la cola y se
recalcula el tiempo en que debe expirar el primero.
• domain
• buffer_ieee754
Módulo experimental en fase de desarrollo y, por tanto, no
cargado por defecto para evitar problemas, aunque los Implementa la lectura y escritura de números en formato
autores de la plataforma aseguran un impacto mínimo. La idea de coma flotante según el estándar IEEE754 del IEEE16
detrás de este él es la de agrupar múltiples acciones de que el módulo buffer emplea para las operaciones con
Entrada/Salida diferentes de tal manera que se dotan de un Doubles y Floats.
contexto definido para manejar los errores que puedan
derivarse de ellas. • constants

Todas las constantes posibles disponibles de la

De esta manera el contexto no se pierde e incluso el
plataforma como, por ejemplo, las relacionadas con POSIX
programa continua su ejecución.
para señales del sistema operativo y modos de manejo de
ficheros. Sólo realiza un binding con node_constants.cc.
Quedan una serie de librerías, que no se mencionan en la
documentación del API pero que existen en el directorio lib/ del
código fuente. Estas librerías tienen propósitos auxiliares para
el resto de los módulos, aunque se pueden utilizarlas a través
de require():
 JavaScript en el lado servidor: NodeJS |

• freelist • sys

Proporciona una sencilla estructura de pool o conjunto de Es un módulo deprecado, en su lugar se debe emplear el
objetos de la misma clase (de hecho, el constructor de los módulo utils.
mismos es un argumento necesario).

Su utilidad se pone de manifiesto en el módulo http,

donde se mantiene un conjunto de parsers HTTP
reutilizables, que se encargan de procesar las peticiones
HTTP que recibe un Servidor.