El Libro para Principiantes en Node.js
Un tutorial de Node.js por: Manuel Kiessling & Herman A. Junge
Sobre el Tutorial
El objetivo de este documento es ayudarte a empezar con el desarrollo de aplicaciones para Node.js, enseñándote todo lo que necesites saber acerca de JavaScript "avanzado" sobre la marcha. Este tutorial va mucho más allá del típico manual "Hola Mundo".
Audiencia Objetivo
Este documento probablemente será mejor entendido por los lectores que tengan un trasfondo similar al mío: Programadores experimentados en al menos un lenguaje orientado al objeto, como Ruby, Python, PHP o Java; poca experiencia con JavaScript, y ninguna experiencia en Node.js.
El que este documento esté orientado a desarrolladores que ya tienen experiencia con otros lenguajes de programación significa que no vamos a cubrir temas realmente básicos como tipos de datos, variables, estructuras de control y similares. Debes saber acerca de estos tópicos para entender este documento.
Sin embargo, dado que las funciones y objetos en JavaScript son diferentes de sus contrapartes en la mayoría de los lenguajes, estos serán explicados con más detalle.
JavaScript y Node.js
JavaScript y Tú
Antes que hablemos de toda la parte técnica, tomémonos un minuto y hablemos acerca de ti y tu relación con JavaScript. Este capítulo está aquí para permitirte estimar si tiene sentido el que sigas o no leyendo este documento.
Si eres como yo, empezaste con el "desarrollo" HTML hace bastante tiempo, escribiendo documentos HTML. Te encontraste en el camino con esta cosa simpática llamada JavaScript, pero solo la usabas en una forma muy básica, agregando interactividad a tus páginas de cuando en cuando.
Lo que realmente quisiste era "la cosa real", Querías saber cómo construir sitios web complejos - Aprendiste un lenguaje de programación como PHP, Ruby, Java, y empezaste a escribir código "backend".
No obstante, mantuviste un ojo en JavaScript, y te diste cuenta que con la introducción de jQuery, Prototype y otros, las cosas se fueron poniendo más avanzadas en las Tierras de JavaScript, y que este lenguaje era realmente más que hacer un window.open().
Sin embargo, esto era todo cosa del frontend ,y aunque era agradable contar con jQuery a tu disposición en cualquier momento que te sintieras con ánimo de sazonar una página web, al final del día, lo que eras a lo más, era un usuario de JavaScript, pero no, un desarrollador de JavaScript.
Y entonces llegó Node.js. JavaScript en el servidor, ¿Qué hay con eso?
Decidiste que era ya tiempo de revisar el nuevo JavaScript. Pero espera: Escribir aplicaciones Node.js es una cosa ; Entender el porqué ellas necesitan ser escritas en la manera que lo son significa entender JavaScript! Y esta vez es en serio.
Y aquí está el problema: Ya que JavaScript realmente vive dos, o tal vez tres vidas (El pequeño ayudante DHTML de mediados de los 90's, las cosas más serias tales como jQuery y similares, y ahora, el lado del servidor), no es tan fácil encontrar información que te ayude a aprender JavaScript de la "manera correcta", de forma de poder escribir aplicaciones de Node.js en una apariencia que te haga sentir que no sólo estás usando JavaScript, sino que también están desarrollando con él.
Porque ahí está el asunto: Ya eres un desarrollador experimentado, y no quieres aprender una nueva técnica simplemente metiendo código aquí y allá mal-aprovechándolo; Quieres estar seguro que te estás enfocando en un ángulo correcto.
Hay, por supuesto, excelente documentación afuera. Pero la documentación por sí sola no es suficiente. Lo que se necesita es una guía.
Mi objetivo es proveerte esta guía.
JavaScript del Lado del Servidor
Las primeras encarnaciones de JavaScript vivían en los browsers. Pero esto es sólo el contexto. Define lo que puedes hacer con el lenguaje, pero no dice mucho acerca de lo que el lenguaje mismo puede hacer. JavaScript es un lenguaje "completo": Lo puedes usar en muchos contextos y alcanzar con éste, todo lo que puedes alcanzar con cualquier otro lenguaje "completo".
Node.js realmente es sólo otro contexto: te permite correr código JavaScript en el backend, fuera del browser.
Para ejecutar el código JavaScript que tu pretendes correr en el backend, este necesita ser interpretado y, bueno, ejecutado, Esto es lo que Node.js realiza, haciendo uso de la Maquina Virtual V8 de Google, el mismo entorno de ejecución para JavaScript que Google Chrome utiliza.
Además, Node.js viene con 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.
Entonces, Node.js es en realidad dos cosas: un entorno de ejecución y una librería.
Para hacer uso de éstas (la librería y el entorno), Necesitas instalar Node.js. En lugar de repetir el proceso aquí. Te ruego visitar las instrucciones oficiales de instalación, Por Favor vuelve una vez que estés arriba y corriendo tu versión de Node.js
Para instalar Node.js visita la siguiente pagina:
https://github.com/joyent/node/wiki/Installation
Ok. Saltemos entonces al agua fría y escribamos nuestra primera aplicación Node.js: "Hola Mundo".
Abre tu editor favorito y crea un archivo llamado holamundo.js. Nosotros queremos escribir "Hola Mundo" a STDOUT, y aquí está el código necesario para hacer esto:
console.log("Hola Mundo";
Graba el archivo, y ejecútalo a través de Node.js:
node holamundo.js
Este debería retornar Hola Mundo en tu monitor.
Ok, esto es aburrido, de acuerdo? Así que escribamos alguna cosa real.
Una Aplicación Web Completa con Node.js
Los casos de Uso
Mantengámoslo simple, pero realista:
El Usuario debería ser capaz de ocupar nuestra aplicación con un browser.
El Usuario debería ver una página de bienvenida cuando solicita http://dominio/inicio, la cual despliega un formulario de súbida.
Eligiendo un archivo de imagen para subir y enviando el formulario, la imagen debería ser subida a http://dominio/subir, donde es desplegada una vez que la súbida este finalizada.
Muy bien. Ahora, tu puedes ser capaz de alcanzar este objetivo googleando y programando lo que sea, pero eso no es lo que queremos hacer aquí.
Más que eso, no queremos escribir simplemente el código más básico posible para alcanzar este objetivo, no importa lo elegante y correcto que pueda ser este código. Nosotros agregaremos intencionalmente más abstracción de la necesaria de manera de poder tener una idea de lo que es construir aplicaciones más complejas de Node.js.
La Pila de Aplicaciones
Hagamos un desglose a nuestra aplicación. ¿Qué partes necesitan ser implementadas para poder satisfacer nuestros casos de uso?
Queremos servir páginas web, de manera que necesitamos un Servidor HTTP.
Nuestro servidor necesitará responder directamente peticiones (requests), dependiendo de qué URL sea pedida en este requerimiento, es que necesitaremos algún tipo de enrutador (router) de manera de mapear los peticiones a los handlers (manejadores) de éstos.
Para satisfacer a los peticiones que llegaron al servidor y han sido ruteados usando el enrutador, necesitaremos de hecho handlers (manejadores) de peticiones
El Enrutador probablemente debería tratar cualquier información POST que llegue y dársela a los handlers de peticiones en una forma conveniente, luego necesitaremos manipulación de data de petición
Nosotros no solo queremos manejar peticiones de URLs, sino que también queremos desplegar contenido cuando estas URLs sean pedidas, lo que significa que necesitamos algún tipo de lógica en las vistas a ser utilizada por los handlers de peticiones, de manera de poder enviar contenido al browser del Usuario.
Por último, pero no menos importante, el Usuario será capaz de subir imágenes, así que necesitaremos algún tipo de manipulación de subidas quien se hará cargo de los detalles.
Pensemos un momento acerca de como construiríamos esta pila de aplicaciones con PHP. No es exactamente un secreto que la configuración típica sería un Apache HTTP server con mod_php5 instalado.
Lo que, a su vez, significa que el tema "Necesitamos ser capaces de servir páginas web y recibir peticiones HTTP" ni siquiera sucede dentro de PHP mismo.
Bueno, con Node.js, las cosas son un poco distintas. Porque con Node.js, no solo implementamos nuestra aplicación, nosotros también implementamos todo el servidor HTTP completo. De hecho, nuestra aplicación web y su servidor web son básicamente lo mismo.
Esto puede sonar como mucho trabajo, pero veremos en un momento que con Node.js, no lo es.
Empecemos por el principio e implementemos la primera parte de nuestra pila, el servidor HTTP..
Construyendo la Pila de Aplicaciones
Un Servidor HTTP Básico
Cuando llegué al punto donde quería empezar con mi primera aplicación Node.js "real", me pregunté no solo como la iba a programar, sino que también, como organizar mi código.
¿Necesitaré tenerlo todo en un archivo? Muchos tutoriales en la Web que te enseñan cómo escribir un servidor HTTP básico en Node.js tienen toda la lógica en un solo lugar. ¿Qué pasa si yo quiero asegurarme que mi código se mantenga leíble a medida que le vaya agregando más cosas?
Resulta, que es relativamente fácil de mantener los distintos aspectos de tu código separados, poniéndolos en módulos.
Esto te permite tener un archivo main limpio, en el cual ejecutas Node.js, y módulos limpios que pueden ser utilizados por el archivo main entre muchos otros.
Así que vamos a crear un archivo main el cual usaremos para iniciar nuestra aplicación, y un archivo de módulo dónde residirá el código de nuestro servidor HTTP.
Mi impresión es que es más o menos un estándar nombrar a tu archivo principal como index.js. Tiene sentido también que pongamos nuestro módulo de servidor en un archivo llamado server.js.
Empecemos con el módulo del servidor. Crea el archivo server.js en el directorio raíz de tu proyecto, y llénalo con el código siguiente:
var http = require("http"; http.createServer(function(request, response) { response.writeHead(200, {"Content-Type": "text/html"}); response.write("Hola Mundo"; response.end(); }).listen(8888);
Eso es! Acabas de escribir un servidor HTTP activo. Probémoslo ejecutándolo y testeándolo. Primero ejecuta tu script con Node.js:
node server.js
Ahora, abre tu browser y apúntalo a http://localhost:8888/. Esto debería desplegar una página web que diga "Hola Mundo".
Interesante, ¿no? ¿Qué tal si hablamos de que está pasando aquí y dejamos la pregunta de 'cómo organizar nuestro proyecto' para después? Prometo que volveremos a esto.
Analizando nuestro servidor HTTP
Bueno, entonces, analicemos que está pasando aquí.
La primera línea require, requiere al módulo http que viene incluido con Node.js y lo hace accesible a través de la variable http.
Luego llamamos a una de las funciones que el módulo http ofrece: createServer. Esta función retorna un objeto, y este objeto tiene un método llamado listen (escucha), y toma un valor numérico que indica el número de puerto en que nuestro servidor HTTP va a escuchar.
Por favor ignora por un segundo a la definición de función que sigue a la llave de apertura de http.createServer.
Nosotros podríamos haber escrito el código que inicia a nuestro servidor y lo hace escuchar al puerto 8888 de la siguiente manera:
var http = require("http"; var server = http.createServer(); server.listen(8888);
Esto hubiese iniciado al servidor HTTP en el puerto 8888 y no hubiese hecho nada más (ni siquiera respondido alguna petición entrante).
La parte realmente interesante (y rara, si tu trasfondo es en un lenguaje más conservador, como PHP) es que la definición de función está ahí mismo donde uno esperaría el primer parámetro de la llamada a createServer().
Resulta que, este definición de función ES el primer (y único) parámetro que le vamos a dar a la llamada a createServer(). Ya que en JavaScript, las funciones pueden ser pasadas de un lado a otro como cualquier otro valor.
Pasando Funciones de un Lado a Otro
Puedes, por ejemplo, hacer algo como esto:
function decir(palabra) { console.log(palabra); } function ejecutar(algunaFuncion, valor) { algunaFuncion(valor); } ejecutar(decir, "Hola";
Lee esto cuidadosamente! Lo que estamos haciendo aquí es, nosotros pasamos la función decir() como el primer parámetro de la función ejecutar. No el valor de retorno de decir, sino que decir() misma!
Entonces, decir se convierte en la variable local algunaFuncion dentro de ejecutar, y ejecutar puede llamar a la función en esta variable usando algunaFuncion() (agregando llaves).
Por supuesto, dado que decir toma un parámetro, ejecutar puede pasar tal parámetro cuando llama a algunaFuncion.
Nosotros podemos, tal como lo hicimos, pasar una función por su nombre como parámetro a otra función. Pero no estamos obligados a tener que definir la función primero y luego pasarla. Podemos también definir y pasar la función como un parámetro a otra función todo al mismo tiempo:
function ejecutar(algunaFuncion, valor) { algunaFuncion(valor); } ejecutar(function(palabra){ console.log(palabra) }, "Hola";
(N.del T.: function es una palabra clave de JavaScript).
Nosotros definimos la función que queremos pasar a ejecutar justo ahí en el lugar donde ejecutar espera su primer parámetro.
De esta manera, no necesitamos darle a la función un nombre, por lo que esta función es llamada función anónima.
Esta es una primera ojeada a lo que me gusta llamar JavaScript "avanzado". Pero tomémoslo paso a paso. Por ahora, aceptemos que en JavaScript, nosotros podemos pasar una función como un parámetro cuando llamamos a otra función. Podemos hacer esto asignando nuestra función a una variable, la cual luego pasamos, o definiendo la función a pasar en el mismo lugar.
De Qué manera el pasar funciones hace que nuestro servidor HTTP funcione
Con este conocimiento, Volvamos a nuestro servidor HTTP minimalista:
var http = require("http"; http.createServer(function(request, response) { response.writeHead(200, {"Content-Type": "text/html"}); response.write("Hola Mundo"; response.end(); }).listen(8888);
A estas alturas, debería quedar claro lo que estamos haciendo acá: Estamos pasándole a la función createServer una función anónima.
Podemos llegar a lo mismo refactorizando nuestro código así:
var http = require("http"; function onRequest(request, response) { response.writeHead(200, {"Content-Type": "text/html"}); response.write("Hola Mundo"; response.end(); } http.createServer(onRequest).listen(8888);
Quizás ahora es un buen momento para preguntar: ¿Por Qué estamos haciendo esto de esta manera?
Callbacks Manejadas por Eventos
La respuesta a) No es una no muy fácil de dar (al menos para mí), y b) Yace en la naturaleza misma de como Node.js trabaja: Está orientado al evento, esa es la razón de por qué es tan rápido. Al final todo se reduce al hecho que Node.js trabaja orientado al evento. Ah, y sí, Yo tampoco sé exactamente qué significa eso. Pero voy a hacer un intento de explicar, el porqué esto tiene sentido para nosotros, que queremos escribir aplicaciones web en Node.js.
Cuando nosotros llamamos al método http.createServer, por supuesto que no sólo queremos que el servidor se quede escuchando en algún puerto, sino que también queremos hacer algo cuando hay una petición HTTP a este servidor.
El problema es, que esto sucede de manera asincrónica: Puede suceder en cualquier momento, pero solo tenemos un único proceso en el cual nuestro servidor corre.
Cuando escribimos aplicaciones PHP, esto no nos molesta en absoluto: cada vez que hay una petición HTTP, el servidor web (por lo general Apache) genera un nuevo proceso solo para esta petición, y empieza el script PHP indicado desde cero, el cual es ejecutado de principio a fin.
Así que respecto al control de flujo, estamos en el medio de nuestro programa en Node.js, cuando una nueva petición llega al puerto 8888: ¿Cómo manipulamos esto sin volvernos locos?
Bueno, esta es la parte donde el diseño orientado al evento de Node.js / JavaScript de verdad ayuda, aunque tengamos que aprender nuevos conceptos para poder dominarlo. Veamos como estos conceptos son aplicados en nuestro código de servidor.
Nosotros creamos el servidor, y pasamos una función al método que lo crea. Cada vez que nuestro servidor recibe una petición, la función que le pasamos será llamada.
No sabemos qué es lo que va a suceder, pero ahora tenemos un lugar donde vamos a poder manipular la petición entrante. Es la función que pasamos, sin importar si la definimos o si la pasamos de manera anónima.
Este concepto es llamado un callback (del inglés: call = llamar; y back = de vuelta). Nosotros pasamos una función a algún método, y el método ocupa esta función para llamar (call) de vuelta (back) si un evento relacionado con este método ocurre.
Al menos para mí, esto tomó algún tiempo para ser entendido. Lee el articulo del blog de Felix de nuevo si todavía no te sientes seguro.
Juguemos un poco con este nuevo concepto. ¿Podemos probar que nuestro código continúa después de haber creado el servidor, incluso si no ha sucedido ninguna petición HTTP y la función callback que pasamos no ha sido llamada? Probemos:
var http = require("http"; function onRequest(request, response) { console.log("Peticion Recibida."; response.writeHead(200, {"Content-Type": "text/html"}); response.write("Hola Mundo"; response.end(); } http.createServer(onRequest).listen(8888); console.log("Servidor Iniciado.";
Noten que utilizo console.log para entregar un texto cada vez que la función onRequest (nuestro callback) es gatillada, y otro texto después de iniciar nuestro servidor HTTP.
Cuando iniciamos esta aplicación (con node server.js, como siempre). Esta inmediatamente escribirá en pantalla "Servidor Iniciado" en la línea de comandos. Cada vez que hagamos una petición a nuestro servidor (abriendo http://localhost:8888/ en nuestro browser), el mensaje "Peticion Recibida." va a ser impreso en la línea de comandos.
Esto es JavaScript del Lado del Servidor Asincrónico y orientado al evento con callbacks en acción :-)
(Toma en cuenta que nuestro servidor probablemente escribirá "Petición Recibida." a STDOUT dos veces al abrir la página en un browser. Esto es porque la mayoría de los browsers van a tratar de cargar el favicon mediante la petición http://localhost:8888/favicon.ico cada vez que abras http://localhost:8888/).
Como nuestro Servidor manipula las peticiones
OK, Analicemos rápidamente el resto del código de nuestro servidor, esto es, el cuerpo de nuestra función de callback onRequest().
Cuando la Callback es disparada y nuestra función onRequest() es gatillada, dos parámetros son pasados a ella: request y response.
Estos son objetos, y puedes usar sus métodos para manejar los detalles de la petición HTTP ocurrida y responder a la petición (en otras palabras enviar algo de vuelta al browser que hizo la petición a tu servidor).
Y eso es lo que nuestro código hace: Cada vez que una petición es recibida, usa la función response.writeHead() para enviar un estatus HTTP 200 y un content-type (parámetro que define que tipo de contenido es) en el encabezado de la respuesta HTTP, y la función response.write() para enviar el texto "Hola Mundo" en el cuerpo de la respuesta,
Por último, nosotros llamamos response.end() para finalizar nuestra respuesta
Hasta el momento, no nos hemos interesado por los detalles de la petición, y ese es el porqué no hemos ocupado el objeto request completamente.
Si te intereso el tutorial...podes seguir leyendo el resto...en la fuente, espero te haya servido