El Libro para Principiantes en Node - Js

24/2/2017 ElLibroparaPrincipiantesenNode.jsUntutorialcompletodenode.
js
ElLibroparaPrincipiantes
enNode.js UntutorialdeNode.jspor:ManuelKiessling&HermanA.Junge
SobreelTutorial
El objetivo de este documento es ayudarte a empezar con el desarrollo de
aplicaciones para Node.js, ensendote todo lo que necesites saber acerca de
JavaScript"avanzado"sobrelamarcha.Estetutorialvamuchomsalldeltpico
manual"HolaMundo".
Status
Estsleyendolaversinfinaldeestelibro,esdecir,lasactualizacionessolosern
hechas para corregir errores o para reflejar cambiar en nuevas versiones de
Node.js.
Lasmuestrasdecdigodeestelibroestnprobadasparafuncionarconlaversin
0.6.11deNode.js.
AudienciaObjetivo
Estedocumentoprobablementesermejorentendidoporloslectoresquetengan
un trasfondo similar al mo: Programadores experimentados en al menos un
lenguaje orientado al objeto, como Ruby, Python, PHP o Java poca experiencia
conJavaScript,yningunaexperienciaenNode.js.
Elqueestedocumentoestorientadoadesarrolladoresqueyatienenexperiencia
con otros lenguajes de programacin significa que no vamos a cubrir temas
realmente bsicos como tipos de datos, variables, estructuras de control y
similares.Debessaberacercadeestostpicosparaentenderestedocumento.
Sinembargo,dadoquelasfuncionesyobjetosenJavaScriptsondiferentesdesus
contrapartes en la mayora de los lenguajes, estos sern explicados con ms
detalle.
http://www.nodebeginner.org/indexes.html 1/40
24/2/2017 ElLibroparaPrincipiantesenNode.jsUntutorialcompletodenode.js
Estructuradeestedocumento
AlTrminodeestedocumento,habrscreadounaaplicacinWebcompleta,que
permitaalosusuariosdestaelverpginaswebysubirarchivos.
La cual, por supuesto, no va ser nada como la "aplicacin que va a cambiar el

mundo",noobstanteeso,nosotrosharemosalgomsynovamossloacodificar
unaaplicacinlo"suficientementesimple"parahacerestoscasosdeusoposible,
sinoquecrearemosunframeworksencillo,perocompleto,afindepoder separar
los distintos aspectos de nuestra aplicacin. Vers lo que esto significa en poco
tiempo.
EmpezaremospormirarcmoeldesarrolloenJavaScriptenNode.jsesdiferente
deldesarrolloenJavaScriptenunbrowser.
Luego,nosmantendremosconlaviejatradicindeescribirunaaplicacin"Hola
Mundo",lacualeslaaplicacinmsbsicadeNode.jsque"hace"algo.
Enseguida, discutiremos que tipo de "aplicacin del mundo real" queremos

construir, disectaremos las diferentes partes que necesitan ser implementadas
paraensamblarestaaplicacin,yempezaremostrabajando en cada una de estas
partespasoapaso.
Segn lo prometido, aprenderemos sobre la marcha acerca de algunos de los

muchosconceptosavanzadosdeJavaScript,comohacerusodeellos,yverelpor
qutienesentidoelhacerusodeestosconceptosenvezdelosqueyaconocemos
porotroslenguajesdeprogramacin.
TabladeContenidos
JavaScriptyNode.js
JavaScriptyT
Antesquehablemosdetodalapartetcnica,tommonosunminutoyhablemos
acerca de ti y tu relacin con JavaScript. Este captulo est aqu para permitirte
estimarsitienesentidoelquesigasonoleyendoestedocumento.
Si eres como yo, empezaste con el "desarrollo" HTML hace bastante tiempo,
escribiendo documentos HTML. Te encontraste en el camino con esta cosa
simptica llamada JavaScript, pero solo la usabas en una forma muy bsica,
agregandointeractividadatuspginasdecuandoencuando.
Lo que realmente quisiste era "la cosa real", queras saber cmo construir sitios
webcomplejosAprendisteunlenguajedeprogramacincomoPHP,Ruby,Java,
yempezasteaescribircdigo"backend".
No obstante, mantuviste un ojo en JavaScript, y te diste cuenta que con la

introduccin de jQuery, Prototype y otros, las cosas se fueron poniendo ms
avanzadasenlasTierrasdeJavaScript,yqueestelenguajeerarealmentemsque
hacerunwindow.open().
Sinembargo,estoeratodocosadelfrontend,yaunqueeraagradablecontarcon
jQuery a tu disposicin en cualquier momento que te sintieras con nimo de
sazonarunapginaweb,al final del da, lo que eras a lo ms, era un usuario de
JavaScript,perono,undesarrolladordeJavaScript.
YentoncesllegNode.js.JavaScriptenelservidor,Quhayconeso?
DecidistequeerayatiempoderevisarelnuevoJavaScript.Peroespera:Escribir
aplicacionesNode.jsesunacosaEntenderelporquellasnecesitanserescritas
enlamaneraquelosonsignificaentenderJavaScript!Yestavezesenserio.
Yaquestelproblema:YaqueJavaScriptrealmentevivedos,otalveztresvidas
(ElpequeoayudanteDHTMLdemediadosdelos90's,lascosasmsseriastales
comojQueryy similares, y ahora, el lado del servidor), no es tan fcil encontrar
informacinqueteayudeaaprenderJavaScriptdela"maneracorrecta",deforma
depoderescribiraplicacionesdeNode.jsenunaaparienciaquetehagasentirque
nosloestsusandoJavaScript,sinoquetambinestndesarrollandoconl.
Porque ah est el asunto: Ya eres un desarrollador experimentado,ynoquieres

aprender una nueva tcnica simplemente metiendo cdigo aqu y all mal
aprovechndolo Quieres estar seguro que te ests enfocando en un ngulo
correcto.
Hay,porsupuesto,excelentedocumentacinafuera.Peroladocumentacinpors
solanoessuficiente.Loquesenecesitaesunagua.
Miobjetivoesproveerteestagua.
UnaAdvertencia
HayalgunaspersonasrealmenteexcelenteenJavaScript.Nosoyunadeellas.
Yosoyrealmenteeltipodelquetehehabladoenlosprrafosprevios.Sunpar
de cosas acerca de desarrollar aplicaciones backend, pero an soy nuevo al
JavaScript "real" y an ms nuevo a Node.js. He aprendido solo recientemente
algunodelosaspectosavanzadosdeJavaScript.Nosoyexperimentado.
Porloqueestenoesunlibro"desdenoviciohastaexperto".Esteesmsbienun
libro"desdenovicioanovicioavanzado".
Si no fallo, entonces este ser el tipo de documento que deseo hubiese tenido
cuandoempecconNode.js.
JavaScriptdelLadodelServidor
LasprimerasencarnacionesdeJavaScriptvivanenlosbrowsers.Peroestoesslo
elcontexto.Defineloquepuedeshacerconellenguaje,peronodicemuchoacerca
deloqueellenguaje mismo puede hacer. JavaScript es un lenguaje "completo":
Lo puedes usar en muchos contextos y alcanzar con ste, todo lo que puedes
alcanzarconcualquierotrolenguaje"completo".
Node.jsrealmenteesslootrocontexto:tepermitecorrercdigoJavaScriptenel
backend,fueradelbrowser.
Para ejecutar el cdigo JavaScript que tu pretendes correr en el backend, este

necesita ser interpretado y, bueno, ejecutado, Esto es lo que Node.js realiza,
haciendousodelaMaquinaVirtualV8deGoogle,elmismoentornodeejecucin
paraJavaScriptqueGoogleChromeutiliza.
Adems,Node.jsvieneconmuchosmdulostiles,demaneraquenotienes que
escribirtododecero,comoporejemplo,algoquepongaunstringalaconsola.
Entonces,Node.jsesenrealidaddoscosas:unentornodeejecucinyunalibrera.
Para hacer uso de stas (la librera y el entorno), necesitas instalar Node.js. En
lugar de repetir el proceso aqu, te ruego visitar las instrucciones oficiales de
instalacin.PorfavorvuelveunavezquetengastuversindeNode.jscorriendo.
"HolaMundo"
Ok. Saltemos entonces al agua fra y escribamos nuestra primera aplicacin
Node.js:"HolaMundo".
Abre tu editor favorito y crea un archivo llamado holamundo.js. Nosotros

queremosescribir"HolaMundo"aSTDOUT,yaquestelcdigonecesariopara
haceresto:
console.log("HolaMundo");
Grabaelarchivo,yejectaloatravsdeNode.js:
nodeholamundo.js
EstedeberaretornarHolaMundoentumonitor.
Ok,estoesaburrido,deacuerdo?Asqueescribamosalgunacosareal.
UnaAplicacinWebCompletaconNode.js
LoscasosdeUso
Mantengmoslosimple,perorealista:
ElUsuariodeberasercapazdeocuparnuestraaplicacinconunbrowser.
ElUsuariodeberaverunapginadebienvenidacuandosolicita
http://dominio/inicio,lacualdespliegaunformulariodesubida.
Eligiendounarchivodeimagenparasubiryenviandoelformulario,la
imagendeberasersubidaahttp://dominio/subir,dondeesdesplegadauna
vezquelasubidaestefinalizada.
Muy bien. Ahora, tu puedes ser capaz de alcanzar este objetivo googleando y
programandoloquesea,peroesonoesloquequeremoshaceraqu.
Msqueeso,noqueremosescribirsimplementeelcdigomsbsicoposiblepara
alcanzaresteobjetivo,noimportaloeleganteycorrectoquepuedaserestecdigo.
Nosotros agregaremos intencionalmente ms abstraccin de la necesaria de
maneradepodertenerunaideadeloqueesconstruiraplicacionesmscomplejas
deNode.js.
LaPiladeAplicaciones
Hagamos un desglose a nuestra aplicacin. Qu partes necesitan ser
implementadasparapodersatisfacernuestroscasosdeuso?
Queremosservirpginasweb,demaneraquenecesitamosunServidor
HTTP.
Nuestroservidornecesitarresponderdirectamentepeticiones(requests),
dependiendodequURLseapedidaenesterequerimiento,esque
necesitaremosalgntipodeenrutador(router)demanerademapearlos
peticionesaloshandlers(manejadores)destos.
Parasatisfaceralospeticionesquellegaronalservidoryhansidoruteados
usandoelenrutador,necesitaremosdehechohandlers(manejadores)
depeticiones
ElEnrutadorprobablementedeberatratarcualquierinformacinPOSTque
llegueydrselaaloshandlersdepeticionesenunaformaconveniente,luego
necesitaremosmanipulacindedatadepeticin
NosotrosnosoloqueremosmanejarpeticionesdeURLs,sinoquetambin
queremosdesplegarcontenidocuandoestasURLsseanpedidas,loque
significaquenecesitamosalgntipodelgicaenlasvistasaserutilizada
porloshandlersdepeticiones,demaneradepoderenviarcontenidoal
browserdelUsuario.
Porltimo,peronomenosimportante,elUsuariosercapazdesubir
imgenes,asquenecesitaremosalgntipodemanipulacindesubidas
quienseharcargodelosdetalles.
Pensemos un momento acerca de como construiramos esta pila de aplicaciones

con PHP. No es exactamente un secreto que la configuracin tpica sera un
ApacheHTTPserverconmod_php5instalado.
Loque,asuvez,significaqueeltema"Necesitamossercapacesdeservirpginas
webyrecibirpeticionesHTTP"nisiquierasucededentrodePHPmismo.
Bueno,conNode.js,lascosassonunpocodistintas.PorqueconNode.js,nosolo
implementamos nuestra aplicacin, nosotros tambin implementamos todo el
servidorHTTPcompleto.Dehecho,nuestraaplicacinwebysuservidorwebson
bsicamentelomismo.
Esto puede sonar como mucho trabajo, pero veremos en un momento que con
Node.js,noloes.
Empecemosporelprincipioeimplementemoslaprimerapartedenuestrapila,el
servidorHTTP..
ConstruyendolaPiladeAplicaciones
UnServidorHTTPBsico
CuandollegualpuntodondequeraempezarconmiprimeraaplicacinNode.js
"real", me pregunt no solo como la iba a programar, sino que tambin, como
organizarmicdigo.
Necesitar tenerlo todo en un archivo? Muchos tutoriales en la Web que te
enseancmoescribirunservidorHTTPbsicoenNode.jstienentodalalgica
enunsololugar.Qupasasiyoquieroasegurarmequemicdigosemantenga
lebleamedidaquelevayaagregandomscosas?
Resulta,queesrelativamentefcildemantenerlosdistintosaspectosdetucdigo
separados,ponindolosenmdulos.
Esto te permite tener un archivo main limpio, en el cual ejecutas Node.js, y

mdulos 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
aplicacin, y un archivo de mdulo dnde residir el cdigo de nuestro servidor
HTTP.
Miimpresinesqueesmsomenosunestndarnombraratuarchivoprincipal
comoindex.js.Tienesentidotambinquepongamosnuestromdulodeservidor
enunarchivollamadoserver.js.
Empecemosconelmdulodelservidor.Creaelarchivoserver.jseneldirectorio
razdetuproyecto,yllnaloconelcdigosiguiente:
varhttp=require("http");
http.createServer(function(request,response){
response.writeHead(200,{"ContentType":"text/html"});
response.write("HolaMundo");
response.end();
}).listen(8888);
Eso es! Acabas de escribir un servidor HTTP activo. Probmoslo ejecutndolo y

testendolo.PrimeroejecutatuscriptconNode.js:
nodeserver.js
Ahora, abre tu browser y apntalo a http://localhost:8888/. Esto debera

desplegarunapginawebquediga"HolaMundo".
Interesante, no? Qu tal si hablamos de que est pasando aqu y dejamos la

pregunta de 'cmo organizar nuestro proyecto' para despus? Prometo que
volveremosaesto.
AnalizandonuestroservidorHTTP
Bueno,entonces,analicemosqueestpasandoaqu.
Laprimeralnearequire,requierealmdulohttpquevieneincluidoconNode.jsy
lohaceaccesibleatravsdelavariablehttp.
Luegollamamosaunadelasfuncionesqueelmdulohttpofrece:createServer.
Esta funcin retorna un objeto, y este objeto tiene un mtodo llamado listen
(escucha), y toma un valor numrico que indica el nmero de puerto en que
nuestroservidorHTTPvaaescuchar.
Porfavorignoraporunsegundoaladefinicindefuncinquesiguealallavede
aperturadehttp.createServer.
Nosotrospodramoshaberescritoelcdigoqueiniciaanuestroservidorylohace
escucharalpuerto8888delasiguientemanera:
varserver=http.createServer();
server.listen(8888);
Esto hubiese iniciado al servidor HTTP en el puerto 8888 y no hubiese hecho

nadams(nisiquierarespondidoalgunapeticinentrante).
La parte realmente interesante (y rara, si tu trasfondo es en un lenguaje ms

conservador, como PHP) es que la definicin de funcin est ah mismo donde
unoesperaraelprimerparmetrodelallamadaacreateServer().
Resulta que, este definicin de funcin ES el primer (y nico) parmetro que le

vamos a dar a la llamada a createServer(). Ya que en JavaScript, las funciones
puedenserpasadasdeunladoaotrocomocualquierotrovalor.
PasandoFuncionesdeunLadoaOtro
Puedes,porejemplo,haceralgocomoesto:
functiondecir(palabra){
console.log(palabra);
}
functionejecutar(algunaFuncion,valor){
algunaFuncion(valor);
}
ejecutar(decir,"Hola");
Leeestocuidadosamente!Loqueestamoshaciendoaques,nosotrospasamosla
funcin decir() como el primer parmetro de la funcin ejecutar. No el valor de
retornodedecir,sinoquedecir()misma!
Entonces, decir se convierte en la variable local algunaFuncion dentro de

ejecutar, y ejecutar puede llamar a la funcin en esta variable usando
algunaFuncion()(agregandollaves).
Por supuesto, dado que decir toma un parmetro, ejecutar puede pasar tal
parmetrocuandollamaaalgunaFuncion.
Nosotrospodemos,talcomolohicimos,pasarunafuncinpor su nombre como

parmetroaotrafuncin.Peronoestamosobligadosatenerquedefinirlafuncin
primero y luego pasarla. Podemos tambin definir y pasar la funcin como un
parmetroaotrafuncintodoalmismotiempo:
functionejecutar(algunaFuncion,valor){
algunaFuncion(valor);
}
ejecutar(function(palabra){console.log(palabra)},"Hola");
(N.delT.:functionesunapalabraclavedeJavaScript).
Nosotrosdefinimoslafuncinquequeremospasaraejecutarjustoahenellugar
dondeejecutaresperasuprimerparmetro.
De esta manera, no necesitamos darle a la funcin un nombre, por lo que esta

funcinesllamadafuncinannima.
EstaesunaprimeraojeadaaloquemegustallamarJavaScript"avanzado".Pero
tommoslo paso a paso. Por ahora, aceptemos que en JavaScript, nosotros
podemospasarunafuncincomounparmetrocuandollamamosaotrafuncin.
Podemos hacer esto asignando nuestra funcin a una variable, la cual luego
pasamos,odefiniendolafuncinapasarenelmismolugar.
DeQumaneraelpasarfuncioneshaceque
nuestroservidorHTTPfuncione
Conesteconocimiento,VolvamosanuestroservidorHTTPminimalista:
http.createServer(function(request,response){
response.end();
}).listen(8888);
A estas alturas, debera quedar claro lo que estamos haciendo ac: Estamos
pasndolealafuncincreateServerunafuncinannima.
Podemosllegaralomismorefactorizandonuestrocdigoas:
functiononRequest(request,response){
response.end();
}
http.createServer(onRequest).listen(8888);
Quizs ahora es un buen momento para preguntar: Por Qu estamos haciendo

estodeestamanera?
CallbacksManejadasporEventos
La respuesta a) No es algo fcil de explicar (al menos para m), y b) Yace en la
naturaleza misma de como Node.js trabaja: Est orientado al evento, esa es la
razndeporquestanrpido.
Podras tomarte un tiempo para leer este excelente post (en ingls) de Felix
Geisendrdfer:Understandingnode.jsparaalgunaexplicacindetrasfondo.
AlfinaltodosereducealhechoqueNode.jstrabajaorientadoalevento.Ah,ys,
yo tampoco s exactamente qu significa eso. Pero voy a hacer un intento de
explicar, el por qu esto tiene sentido para nosotros, que queremos escribir
aplicacioneswebenNode.js.
Cuandonosotrosllamamosalmtodohttp.createServer,porsupuestoquenoslo
queremosqueelservidorsequedeescuchandoenalgnpuerto,sinoquetambin
queremoshaceralgocuandohayunapeticinHTTPaesteservidor.
Elproblemaes,queestosucededemaneraasncrona:Puedesucederencualquier
momento,perosolotenemosunnicoprocesoenelcualnuestroservidorcorre.
Cuando escribimos aplicaciones PHP, esto no nos molesta en absoluto: cada vez
que hay una peticin HTTP, el servidor web (por lo general Apache) genera un
nuevo proceso solo para esta peticin, y empieza el script PHP indicado desde
cero,elcualesejecutadodeprincipioafin.
Asquerespectoalcontroldeflujo,estamosenelmediodenuestroprogramaen
Node.js, cuando una nueva peticin llega al puerto 8888: Cmo manipulamos
estosinvolvernoslocos?
Bueno,estaeslapartedondeeldiseoorientadoaleventodeNode.js/JavaScript
de verdad ayuda, aunque tengamos que aprender nuevos conceptos para poder
dominarlo. Veamos como estos conceptos son aplicados en nuestro cdigo de
servidor.
Nosotroscreamoselservidor,ypasamosunafuncinalmtodoquelocrea.Cada
vez que nuestro servidor recibe una peticin, la funcin que le pasamos ser
llamada.
Nosabemosquesloquevaasuceder,peroahoratenemosunlugardondevamos
apodermanipularlapeticinentrante.Eslafuncinquepasamos,sinimportarsi
ladefinimososilapasamosdemaneraannima.
Esteconceptoesllamadouncallback(N.delT.:delingls:call=llamaryback=
devuelta).Nosotrospasamosunafuncinaalgnmtodo,yelmtodoocupaesta
funcin para llamar (call) de vuelta (back) si un evento relacionado con este
mtodoocurre.
Almenosparam,estotomalgntiempoparaserentendido.Leeelarticulodel
blogdeFelixdenuevositodavanotesientesseguro.
Juguemosunpococonestenuevoconcepto.Podemosprobarquenuestrocdigo
continadespusdehabercreadoelservidor,inclusosinohasucedidoninguna
peticinHTTPylafuncincallbackquepasamosnohasidollamada?Probemos:
console.log("PeticionRecibida.");
response.end();
}
console.log("ServidorIniciado.");
Noten que utilizo console.log para entregar un texto cada vez que la funcin
onRequest(nuestrocallback)esgatillada,yotrotextodespusdeiniciarnuestro
servidorHTTP.
Cuando iniciamos esta aplicacin (con node server.js, como siempre). Esta
inmediatamenteescribirenpantalla"ServidorIniciado"enlalneadecomandos.
Cada vez que hagamos una peticin a nuestro servidor (abriendo
http://localhost:8888/ennuestrobrowser),elmensaje"PeticionRecibida."vaa
serimpresoenlalneadecomandos.
Esto es JavaScript del lado del servidor asncrono y orientado al evento con
callbacksenaccin:)
(Toma en cuenta que nuestro servidor probablemente escribir "Peticin

Recibida."aSTDOUTdosvecesalabrirlapginaenunbrowser.Estoesporquela
mayora de los browsers van a tratar de cargar el favicon mediante la peticin
http://localhost:8888/favicon.icocadavezqueabrashttp://localhost:8888/).
ComonuestroServidormanipulalaspeticiones
OK, analicemos rpidamente el resto del cdigo de nuestro servidor, esto es, el
cuerpodenuestrafuncindecallbackonRequest().
Cuando la callback es disparada y nuestra funcin onRequest() es gatillada, dos

parmetrossonpasadosaella:requestyresponse.
Estos son objetos, y puedes usar sus mtodos para manejar los detalles de la
peticinHTTPocurridayresponderalapeticin(enotraspalabrasenviaralgode
vueltaalbrowserquehizolapeticinatuservidor).
Yesoesloquenuestrocdigohace:cadavezqueunapeticinesrecibida,usala
funcin response.writeHead() para enviar un estatus HTTP 200 y un content
type (parmetro que define que tipo de contenido es) en el encabezado de la
respuestaHTTP,ylafuncinresponse.write()paraenviareltexto"HolaMundo"
enelcuerpodelarespuesta.
Porltimo,nosotrosllamamosresponse.end()parafinalizarnuestrarespuesta.
Hastaelmomento,nonoshemosinteresadoporlosdetallesdelapeticin,yese
eselporqunohemosocupadoelobjetorequestcompletamente.
Encontrandounlugarparanuestromdulode
servidor
OK,prometquevolveramosaalCmoorganizarnuestraaplicacin.Tenemosel
cdigodenuestroservidorHTTPmuybsicoenelarchivoserver.js,ymencion
que es comn tener un archivo principal llamado index.js, el cual es usado para
arrancar y partir nuestra aplicacin haciendo uso de los otros mdulos de la
aplicacin(comoelmdulodeservidorHTTPqueviveenserver.js).
Hablemosdecomopodemoshacerquenuestroserver.jsseaunverdaderomdulo
Node.jsyquepuedaserusadopornuestroprontoaserescritoarchivoprincipal
index.js.
Comohabrnnotado,yahemosusadomdulosennuestrocdigo,comoste:
...
http.createServer(...);
EnalgnlugardentrodeNode.jsviveunmdulollamado"http",ypodemoshacer
uso de ste en nuestro propio cdigo requirindolo y asignando el resultado del
requerimientoaunavariablelocal.
Esto transforma a nuestra variable local en un objeto que acarrea todos los
mtodospblicosqueelmdulohttpprovee.
Es prctica comn elegir el nombre del mdulo como nombre para nuestra
variablelocal,perosomoslibresdeescogercualquieraquenosguste:
varfoo=require("http");
...
foo.createServer(...);
Bien. Ya tenemos claro como hacer uso de los mdulos internos de Node.js.
Cmohacemosparacrearnuestrospropiosmdulos,yCmolosutilizamos?
Descubrmoslotransformandonuestroscriptserver.jsenunmduloreal.
Sucedeque,notenemosquetransformarlotanto.Hacerquealgncdigoseaun
Mdulo, significa que necesitamos exportar las partes de su funcionalidad que
queremosproveeraotrosscriptsquerequierannuestromdulo.
Por ahora, la funcionalidad que nuestro servidor HTTP necesita exportar es

simple:Permitiralosscriptsqueutilicenestemduloarrancarelservidor.
Parahacerestoposible,dotaremosalcdigodenuestroservidordeunafuncin
llamadainicio,yexportaremosestafuncin:
functioniniciar(){
console.log("PeticinRecibida.");
response.end();
}
}
exports.iniciar=iniciar;
Deestemodo,Podemoscrearnuestropropioarchivoprincipalindex.js,yarrancar
nuestro servidor HTTP all, aunque el cdigo para el servidor este en nuestro
archivoserver.js.
Creaunarchivoindex.jsconelsiguientecontenido:
varserver=require("./server");
server.iniciar();
Como puedes ver, nosotros utilizamos nuestro mdulo de servidor tal como
cualquier otro mdulo interno: requiriendo el archivo donde est contenido y
asignndolo a una variable, con las funciones que tenga 'exportadas' disponibles
paranosotros.
Eso es. Podemos ahora arrancar nuestra aplicacin por medio de nuestro script
principal,yvaahacerexactamentelomismo:
nodeindex.js
Bien,ahorapodemosponerlasdiferentespartesdenuestraaplicacinenarchivos
diferentesyenlazarlasjuntasatravsdelacreacindeestosmdulos.
Tenemosslolaprimerapartedenuestraaplicacinensulugar:Podemosrecibir
peticionesHTTP.Peronecesitamoshaceralgoconellasnecesitamos reaccionar
de manera diferente, dependiendo de que URL el browser requiera de nuestro
servidor.
Para una aplicacin muy simple, podras hacer esto directamente dentro de una
funcin de callback OnRequest(). Pero, como dije, agreguemos un poco ms de
abstraccin,demaneradehacernuestraaplicacinmsinteresante.
HacerdiferentespeticionesHTTPirapartesdiferentesdenuestrocdigosellama
"ruteo" (N. del T.: routing, en ingls) bueno, entonces, creemos un mdulo
llamadorouter.
Qusenecesitapara"rutear"peticiones?
NecesitamossercapacesdeentregarlaURLrequeridaylosposiblesparmetros
GET o POST adicionales a nuestro router, y basado en estos, el router debe ser
capazdedecidirqucdigoejecutar(este"cdigoaejecutar"eslatercerapartede
nuestra aplicacin: una coleccin de manipuladores de peticiones que harn el
verdaderotrabajocuandounapeticinesrecibida).
Asque,NecesitamosmirarenlaspeticionesHTTPyextraerlaURLrequerida,as
como los parmetros GET/POST de ellos. Se puede discutir acerca de si este
procedimientodebeserpartedelrouterodelservidor(osilohacemosunmdulo
por s mismo), pero hagamos el acuerdo de hacerlo parte de nuestro servidor
HTTPporahora.
Todalainformacinquenecesitamosestdisponibleenelobjetorequest,elque
es pasado como primer parmetro a nuestra funcin callback onRequest(). Pero
para interpretar esta informacin, necesitamos algunos mdulos adicionales
Node.js,llamadosurlyquerystring.
El mdulo url provee mtodos que nos permite extraer las diferentes partes de
una URL (como por ejemplo la ruta requerida y el string de consulta), y
querystringpuede,encambio,serusadopara parsear el string de consulta para
losparmetrosrequeridos:
url.parse(string).query
|
url.parse(string).pathname|
||
||

http://localhost:8888/iniciar?foo=bar&hello=world

||
||
querystring(string)["foo"]|
|
querystring(string)["hello"]
Podemos, por supuesto, tambin utilizar querystring para parsear el cuerpo de

unapeticinPOSTenbuscadeparmetros,comoveremosmstarde.
Agreguemos ahora a nuestra funcin onRequest() la lgica requerida para

encontrarquerutaURLelbrowsersolicit:
varurl=require("url");
functioniniciar(){
varpathname=url.parse(request.url).pathname;
console.log("Peticinpara"+pathname+"recibida.");
response.end();
}
}
MuyBien.Nuestraaplicacinpuedeahoradistinguirpeticionesbasadasenlaruta
URLrequeridaestonospermitemapearpeticioneshacianuestromanipuladores
de peticiones, basndonos en la ruta URL usando nuestro (pronto a ser escrito)
router.Luego,podemos construir nuestra aplicacin en una forma REST (N. del
T.:RESTfulwayenIngls),yaqueahorapodemosimplementarunainterfazque
sigue los principios que guan a la Identificacin de Recursos (ve por favor el
artculodeWikipediaacercadelaTransferenciadelEstadoRepresentacionalpara
informacindetrasfondo.
En el contexto de nuestra aplicacin, esto significa simplemente que seremos

capacesdetenerpeticionesparalasURLs/iniciary/subirmanejadasporpartes
diferentesdenuestrocdigo.Veremosprontocomotodoestoencaja.
OK,eshoradeescribirnuestrorouter.Vamosacrearunnuevoarchivollamado
router.js,conelsiguientecontenido:
functionroute(pathname){
console.log("Apuntoderutearunapeticionpara"+pathname);
}
exports.route=route;
Por supuesto, este cdigo no est haciendo nada, pero eso est bien por ahora.
Empecemosavercomovamosaencajaresterouterconnuestroservidorantesde
ponermslgicaenelrouter.
Nuestro servidor HTTP necesita saber y hacer uso de nuestro router. Podemos
escribir directamente esta dependencia a nuestro servidor, pero como hemos
aprendido de la manera difcil en nuestras experiencias, vamos a acoplar de
maneradbil(loosecouplingenIngls)al router y su servidor va inyeccin por
dependencia.Paraunareferenciadefondo,leerelArtculodeMartinFowler(en
Ingls).
Primeroextendamosnuestrafuncininiciar()demaneradepermitirnospasarla
funcinderuteoaserusadacomoparmetro:
functioniniciar(route){
console.log("Peticionpara"+pathname+"recibida.");
route(pathname);
response.end();
}
}
Yextendamosnuestroindex.jsadecuadamente,estoes,inyectandolafuncinde
ruteodenuestrorouterenelservidor:
varrouter=require("./router");
server.iniciar(router.route);
Nuevamente,estamospasandounafuncincomoparmetros,peroestoyanoes
unanovedadparanosotros.
Siarrancamosnuestraaplicacinahora(nodeindex.jscomosiempre),yhacemos
unapeticinparaunaURL,puedesverahoraporlasrespuestasdela aplicacin
quenuestroservidorHTTPhaceusodenuestrorouteryleentregaelnombrede
rutarequerido:
bash$nodeindex.js
Peticinpara/foorecibida.
Apuntoderutearunapeticionpara/foo
Heomitidolamolestarespuestadelapeticinpara/favicon.ico
Ejecucinenelreinodelosverbos
Puedodivagarunvezmsporunmomentoyhablaracercadelaprogramacin
funcionaldenuevo?
Pasar funciones no es slo una consideracin tcnica. Con respecto al diseo de

software, esto es casi filosfico. Tan solo piensa en ello: en nuestro archivo de
index, podramos haber entregado el objeto router al servidor, y el servidor
hubiesellamadoalafuncinroutedeesteobjeto.
De esta manera, podramos haber pasado una cosa, y el servidor hubiese usado
esacosaparahaceralgo.Oye,"CosaRouter",Podrasporfavor rutear esto por
m?
Peroelservidornonecesitalacosa.Slonecesitahaceralgo,y para que algo se

haga, no necesitas cosas para nada, slo necesitas acciones. No necesitas
sustantivos,sinoquenecesitasverbos.
Entender este cambio de mentalidad fundamental que est en el ncleo de esta

ideaesloquerealmentemehizoentenderlaprogramacinfuncional.
YloentendmientraslealaobramaestradeSteveYegge(enIngls)Ejecucinen
elReinodelosSustantivos.Anda,lela,porfavor.Esunodelosmejoresartculos
relacionadosconelsoftwarequehayatenidoelplacerdeencontrar.
Ruteandoalosverdaderosmanipuladoresde
peticiones
Volviendo al tema. Nuestro servidor HTTP y nuestro router de peticiones son
ahoralosmejoresamigosyconversanentreellos,talycomopretendimos.
Por supuesto, esto no es suficiente, "Rutear" significa que nosotros queremos

manipularlaspeticionesadistintasURLsdemanera,diferente.Nosgustaratener
la "lgicas de negocios" para peticiones de /inicio manejadas en otra funcin,
distintaalaquemanejalaspeticionespara/subir.
Porahora,elruteo"termina"enelrouter,yelrouternoesellugardondeseest
"haciendo algo" con las peticiones, ya que esto no escalara bien una vez que
nuestraaplicacinsehagamscompleja.
Llamemos a estas funciones, donde las peticiones estn siendo ruteadas,

manipuladoresdepeticiones(requesthandlers).Yprocedamosconstosahora,
porque,amenosquenolostengamosensulugar,nohaytienemuchosentidoen
hacernadaconelrouterporahora.
Nuevapartedelaaplicacin,significanuevomdulonocreoquehayasorpresa
ac.CreemosunmdulollamadorequestHandlers(N.delT.:pormanipuladores
de peticin), agreguemos un funcin de ubicacin para cada manipulador de
peticin,yexportemosestoscomomtodosparaelmdulo:
functioniniciar(){
console.log("Manipuladordepeticin'iniciar'hasidollamado.");
}
functionsubir(){
console.log("Manipuladordepeticin'subir'hasidollamado.");
}
exports.subir=subir;
Estonospermitiratarlosmanipuladoresdepeticinalrouter,dndoleanuestro
routeralgoquerutear.
Llegado a este punto, necesitamos tomar una decisin: Ingresaremos las rutas
del mdulo requestHandlers dentro del cdigo del router (hardcoding), o
queremosalgomsdedependenciaporinyeccin?Aunqueenladependenciapor
inyeccin, como cualquier otro patrn, no debera ser usada simplemente por
usarla, en este caso tiene sentido acoplar el router dbilmente a sus
manipuladores de peticin, as, de esta manera hacemos que el router sea
reutilizable.
Estosignificaquenecesitamospasarlosmanipuladoresdepeticindesdenuestro
serveralrouter,peroestosesienteequivocado,dadoque,Porqutenemosque
hacerelcaminolargoyentregarlosmanipuladoresdesde el archivo principal al
servidorydeahalrouter?
Cmo vamos a pasarlos? Ahora tenemos slo dos manipuladores, pero en una
aplicacinreal,estenmerosevaaincrementaryvariar,ynosotrosnoqueremos
estar a cada momento mapeando peticiones a manipuladores cada vez que una
nueva URL o manipulador de peticin sea agregado. Y si tenemos un cdigo del
tipoifpeticion==xthenllamamanipuladoryenelrouter,estosepondracada
vezmsfeo.
Unnmerovariabledeitems,cadaunodeellosmapeadosaunstring?(en este
casolaURLrequerida)Bueno,estosuenacomoqueunarrayasociativoharael
truco.
Bueno,estedescubrimientoesobscurecidoporelhechoqueJavaScriptnoprovee
arrays asociativos o s? !Resulta que lo que necesitamos usar son objetos si
necesitamosunarrayasociativo!
Unabuenaintroduccinaestoest(enIngls)enhttp://msdn.microsoft.com/en
us/magazine/cc163419.aspx,Djamecitartelaparterelevante:
En C++ o C#, cuando hablamos acerca de objetos, nos estamos

refiriendo a instancias de clases de estructuras. Los objetos tienen
distintas propiedades y mtodos, dependiendo en las plantillas (esto
es,lasclases)desde donde stos sean instanciados. Este no es el caso
con los objetos de JavaScript. En JavaScript, los objetos son slo
colecciones de pares nombre/valor piensa en un objeto JavaScript

comoenundiccionarioconllavesdestring.
Si los objetos JavaScript son slo colecciones de pares nombre/valor, Cmo

puedenentoncestenermtodos?Bueno,losvalorespuedenserstrings,nmeros,
etc...OFunciones!
OK,ahora,volviendofinalmentealcdigo.Hemosdecididoquequeremospasarla
lista de requestHandlers (manipuladores de peticin) como un objeto, y para
lograresteacoplamientodbil,necesitamosusarlatcnicadeinyectaresteobjeto
enlaroute()(ruta).
Empecemosconponerelobjetoennuestroarchivoprincipalindex.js:
varrouter=require("./router");
varrequestHandlers=require("./requestHandlers");
varhandle={}
handle["/"]=requestHandlers.iniciar;
handle["/iniciar"]=requestHandlers.iniciar;
handle["/subir"]=requestHandlers.subir;
server.iniciar(router.route,handle);
(N.delT.:SeOptapordejarlosverbosenIngls'route'pararuteary'handle'para
manipular).
Aunquehandleesmsuna"cosa"(unacoleccindemanipuladoresde peticin),
propongo que lo nombremos como un verbo, ya que esto resultar en una
expresinfluidaennuestrorouter,comoveremosacontinuacin:
Como puedes ver, es realmente simple mapear diferentes URLs al mismo

manipulador de peticiones: Mediante la adicin de un par llave/valor de "/" y
requestHandlers.iniciar,podemosexpresarenunaformaagradableylimpiaque
noslopeticionesa/start,sinoquetambinpeticionesa/puedensermanejadas
porelmanipuladorinicio.
Despusdedefinirnuestroobjeto,selopasamosalservidorcomounparmetro
adicional.Modifiquemosnuestroserver.jsparahacerusodeeste:
functioniniciar(route,handle){
route(handle,pathname);
response.end();
}
}
Loquehacemosaqu,eschequearsiunmanipuladordepeticionesparaunaruta
dada existe, y si es as, simplemente llamamos a la funcin adecuada. Dado que
podemos acceder a nuestras funciones manipuladoras de peticin desde nuestro
objetodelamismamaneraquehubisemospodidoaccederaunelementodeun
array asociativo, es que tenemos la expresin fluida handle[pathname]() de la
que habl antes, que en otras palabras es: "Por favor, handle (maneja) este(a)
pathname(ruta)".
Bien,Estoestodoloquenecesitamosparaatarservidor,routerymanipuladores
depeticionesjuntos!Unavezquearranquemosnuestraaplicacinyhagamosuna
peticinennuestrobrowserdehttp://localhost:8888/iniciar,vamosaprobarque
elmanipuladordepeticincorrectofue,dehecho,llamado:
ServidorIniciado.
Peticionpara/iniciarrecibida.
Apuntoderutearunapeticinpara/iniciar
Manipuladordepeticion'iniciar'hasidollamado.
HaciendoquelosManipuladoresdePeticiones
respondan
Muybien.Ahora,sitansololosmanipuladoresdepeticinpudieranenviaralgo
devueltaalbrowser,estoseramuchomejor,cierto?
Recuerda,queel"HolaMundo"quetubrowserdespliegaanteunapeticindeuna
pgina,anvienedesdelafuncinonRequestennuestroarchivoserver.js.
"Manipular Peticiones" no significa otra cosa que "Responder a las Peticiones"

despus de todo, as que necesitamos empoderar a nuestros manipuladores de
peticiones para hablar con el browser de la misma manera que la funcin
onRequestlohace.
Cmonosedebehaceresto?
LaaproximacindirectaquenosotrosdesarrolladoresconuntrasfondoenPHP
oRubyquisiramosseguiresdehechoconducenteaerrores:trabajademanera
espectacularalprincipioyparecetenermuchosentido,y de pronto, las cosas se
arruinanenelmomentomenosesperado.
A lo que me refiero con "aproximacin directa" es esto: hacer que los

manipuladores de peticin retornen return() el contenido que ellos quieran
desplegar al usuario, y luego, enviar esta data de respuesta en la funcin
onRequestdevueltaalusuario.
Tanslohagamosesto,yluego,veamosporquestonoestanbuenaidea.
Empecemos con los manipuladores de peticin y hagmoslos retornar, lo que

nosotros queremos desplegar en el browser. Necesitamos modificar
requestHandlers.jsalosiguiente:
functioniniciar(){
console.log("Manipuladordepeticion'iniciar'fuellamado.");
return"HolaIniciar";
}
functionsubir(){
console.log("Manipuladordepeticion'subir'fuellamado.");
return"HolaSubir";
}
Bien. De todas maneras, el router necesita retornar al servidor lo que los

manipuladores de peticin le retornaron a l. Necesitamos entonces editar
router.jsdeestamanera:
functionroute(handle,pathname){
if(typeofhandle[pathname]==='function'){
returnhandle[pathname]();
}else{
console.log("Noseencontromanipuladorpara"+pathname);
return"404NoEncontrado";
}
}
Comopuedesver,nosotrostambinretornaremosalgntextosilapeticinnoes
ruteada.
Porltimo,peronomenosimportante,necesitamosrefactorizarnuestroservidor
para hacerlo responder al browser con el contenido que los manipuladores de
peticinleretornaronvaelrouter,transformandodeestamaneraaserver.jsen:
varcontent=route(handle,pathname)
response.write(content);
response.end();
}
}
Sinosotrosarrancamosnuestraaplicacinreescrita,todovaafuncionaralasmil
maravillas:hacerleunapeticinahttp://localhost:8888/iniciar resulta en "Hola
Iniciar" siendo desplegado en el browser, hacerle una peticin a
http://localhost:8888/subir nos da "Hola Subir", y la peticin a

http://localhost:8888/fooproduce"404NoEncontrado".
OK,entoncesPorquestoesunproblema?Larespuestacortaes:debidoaquesi
uno de los manipuladores de peticin quisiera hacer uso de una operacin no
bloqueante (nonblocking) en el futuro, entonces esta configuracin, como la
tenemos,seraproblemtica.
Tommosnosalgntiempoparalarespuestalarga.
BloqueanteyNoBloqueante
Comosedijo,losproblemasvanasurgircuandonosotrosincluyamosoperaciones
nobloqueantes en los manipuladores de peticin. Pero hablemos acerca de las
operaciones bloqueantes primero, luego, acerca de las operaciones no
bloqueantes.
Y, en vez de intentar explicar que es lo que significa "bloqueante" y "no

bloqueante", demostremos nosotros mismo que es lo que sucede su agregamos
unaoperacinbloqueanteanuestrosmanipuladoresdepeticin.
Para hacer esto, modificaremos nuestro manipulador de peticin iniciar para

hacerunaesperade10segundosantesderetornarsustring"HolaIniciar".Yaque
no existe tal cosa como sleep() en JavaScript, usaremos un hack ingenioso para
ello.
Porfavor,modificarequestHandlers.jscomosigue:
functioniniciar(){
console.log("Manipuladordepeticion'iniciar'fuellamado.");
functionsleep(milliSeconds){
//obtenlahoraactual
varstartTime=newDate().getTime();
//atascalacpu
while(newDate().getTime()<startTime+milliSeconds);
}
sleep(10000);
return"HolaIniciar";
}
functionsubir(){
return"HolaSubir";
}
Dejemos claros que es lo que esto hace: cuando la funcin iniciar() es llamada,
Node.js espera 10 segundos y slo ah retorna "Hola Iniciar". Cuando est
llamandoasubir(),retornainmediatamente,lamismamaneraqueantes.
(Porsupuestolaideaesqueteimaginesque,envezdedormirpor10segundos,
exista una operacin bloqueante verdadera en iniciar(), como algn tipo de
calculodelargoaliento.)
Veamosquesloqueestecambiohace.
Comosiempre,necesitamosreiniciarnuestroservidor.Estavez,tepidosigasun
"protocolo" un poco ms complejo de manera de ver que sucede: Primero, abre
dos ventanas de browser o tablas. En la primera ventana, por favor ingresa
http://localhost:8888/iniciar en la barra de direcciones, pero no abras an esta
url!
En la barra de direcciones de la segunda ventana de browser, ingresa

http://localhost:8888/subiry,nuevamente,nopresionesentertodava.
Ahora, haz lo siguiente: presiona enter en la primera ventana ("/iniciar"), luego,

rpidamentecambiaalasegundaventana("/subir")ypresionaenter,tambin.
Loqueveremosserlosiguiente:LaURL/iniciotoma10segundosencargar,tal
cual esperamos. Pero la URL /subir tambin toma 10 segundos para cargar,
Aunque no hay definido un sleep() en el manipulador de peticiones
correspondiente!
Por qu? simple, porque inicio() contiene una operacin bloqueante. En otras
palabras"Estbloqueandoeltrabajodecualquierotracosa".
He ah el problema, porque, el dicho es: "En Node.js, todo corre en paralelo,

exceptotucdigo".
Lo que eso significa es que Node.js puede manejar un montn de temas

concurrentes, pero no lo hace dividiendo todo en hilos (threads) de hecho,
Node.js corre en un slo hilo. En vez de eso, lo hace ejecutando un loop de
eventos, y nosotros, los desarrolladores podemos hacer uso de esto Nosotros
debemosevitaroperacionesbloqueantesdondeseaposible,yutilizaroperaciones
nobloqueantesensulugar.
Loqueexec()hace,esque,ejecutauncomandodeshelldesdedentrodeNode.js.
Enesteejemplo,vamosausarloparaobtenerunalistadetodoslosarchivosdel
directorioenquenosencontramos("lslah"),permitindonosdesplegarestalista
enelbrowserdeunusuarioqueestepeticionandolaURL/inicio.
Lo que el cdigo hace es claro: crea una nueva variable content() (con el valor
incialde"vaco"),ejecuta"lslah",llenalavariableconelresultado,yloretorna.
Como siempre, arrancaremos nuestra aplicacin y visitaremos

http://localhost:8888/iniciar.
Loquecargaunabellapginaquedespliegaelstring"vaco".Quesloqueest
incorrectoac?
Bueno, como ya habrn adivinado, exec() hace su magia de una manera no

bloqueante. Buena cosa esto, porque de esta manera podemos ejecutar
operacionesdeshellmuycarasenejecucin(como,porejemplo,copiar archivos
enormes o cosas similares) sin tener que forzar a nuestra aplicacin a detenerse
comolohizolaoperacinsleep.
(Si quieres probar esto, reemplaza "ls lah" con una operacin ms cara como
"find/").
Pero no estaramos muy felices si nuestra elegante aplicacin no bloqueante no

desplegaraalgnresultado,cierto?.
Bueno,entonces,arreglmosla.Ymientrasestamoseneso,tratemosdeentender
porqulaarquitecturaactualnofunciona.
Elproblemaesqueexec(),parapodertrabajardemaneranobloqueante,haceuso
deunafuncindecallback.
Ennuestroejemplo,esunafuncinannima,lacualespasadacomoelsegundo
parmetrodelallamadaalafuncinexec():
function(error,stdout,stderr){
content=stdout;
}
Y aqu yace la raz de nuestro problema: nuestro cdigo es ejecutado de manera

sincrnica, lo que significa que inmediatamente despus de llamar a exec(),
Node.jscontinaejecutandoreturncontent.Enestepunto,contenttodavaest
vaco, dado el hecho que la funcin de callback pasada a exec() no ha sido an
llamadaporqueexec()operademaneraasncrona.
Ahora, "ls lah" es una operacin sencilla y rpida (a menos, claro, que hayan
millones de archivos en el directorio). Por lo que es relativamente necesario
llamaralcallbackperodetodasmanerasestosucededemaneraasncrona.
Estosehacemsobvioaltratarconuncomandomscostoso:"find/"setomaun
minutoenmimaquina,perosireemplazo"lslah"con"find/"enelmanipulador
depeticiones,yoreciboinmediatamenteunarespuestaHTTPcuandoabrolaURL
/inicio est claro que exec() hace algo en el trasfondo, mientras que Node.js
mismocontinaconelflujodelaaplicacin,ypodemosasumirquelafuncinde
callbackqueleentregamosaexec()serllamadaslocuandoelcomando"find/"
hayaterminadodecorrer.
Pero,cmopodemosalcanzarnuestrameta,lademostrarlealusuariounalista
dearchivosdeldirectorioactual?
Bueno, despus de aprender como no hacerlo, discutamos cmo hacer que

nuestros manipuladores de peticin respondan a los requerimientosdelbrowser
delamaneracorrecta.
RespondiendoalosManipuladoresdePeticincon
OperacionesNoBloqueantes
Acabo de usar la frase "la manera correcta". Cosa peligrosa. Frecuentemente, no
existeunanica"maneracorrecta".
Pero una posible solucin para esto, frecuente con Node.js es pasar funciones
alrededor.Examinemosesto.
Ahora mismo, nuestra aplicacin es capaz de transportar el contenido desde los

manipuladoresdepeticinalservidorHTTPretornndolohaciaarribaatravsde
lascapasdelaaplicacin(manipuladordepeticin>router>servidor).
Nuestro nuevo enfoque es como sigue: en vez de llevar el contenido al servidor,

llevaremoselservidoralcontenido.Parasermsprecisos,inyectaremoselobjeto
response(respuesta)(desdenuestrafuncindecallbackdeservidoronRequest())
a travs de nuestro router a los manipuladores de peticin. Los manipuladores
serncapacesdeusarlasfuncionesdeesteobjetopararesponderalaspeticiones
ellosmismos.
Suficientes explicaciones, aqu hay una receta paso a paso de como cambiar
nuestraaplicacin.
Empecemosconnuestroservidor,server.js:
route(handle,pathname,response);
}
}
En vez de esperar un valor de respuesta desde la funcin route(), pasmosle un

tercerparmetro:nuestroobjetoresponse.Esms,removamoscualquierllamada
aresponsedesdeelmanipuladoronRequest(),yaqueahoraesperamosqueroute
sehagacargodeesto.
Ahoravienerouter.js:
functionroute(handle,pathname,response){
handle[pathname](response);
}else{
console.log("Nohaymanipuladordepeticionpara"+pathname);
response.write("404NoEncontrado");
response.end();
}
}
Mismo patrn: En vez de esperar que retorne un valor desde nuestros

manipuladoresdepeticin,nosotrostraspasamoselobjetoresponse.
Si no hay manipulador de peticin para utilizar, ahora nos hacemos cargo de

responderconadecuadosencabezadoycuerpo"404".
Y por ltimo, pero no menos importante, modificamos a requestHandlers.js (el

archivodemanipuladoresdepeticin).
varexec=require("child_process").exec;
functioniniciar(response){
console.log("Manipuladordepeticin'iniciar'fuellamado.");
exec("lslah",function(error,stdout,stderr){
response.write(stdout);
response.end();
});
}
functionsubir(response){
console.log("Manipuladordepeticin'subir'fuellamado.");
response.write("HolaSubir");
response.end();
}
Nuestras funciones manipuladoras necesitan aceptar el parmetro de respuesta

response,ydeestamanera,hacerusodeldemaneraderesponderalapeticin
directamente.
El manipulador iniciar responder con el callback annimo exec(), y el

manipulador subir replicar simplemente con "Hola Subir", pero esta vez,
haciendousodelobjetoresponse.
Siarrancamosnuestraaplicacindenuevo(nodeindex.js),estodeberafuncionar
deacuerdoaloesperado.
Si quieres probar que la operacin cara dentro de /iniciar no bloquear ms las

peticionespara/subirqueseanrespondidas inmediatamente, entonces modifica
tuarchivorequestHandlers.jscomosigue:
varexec=require("child_process").exec;
console.log("Manipuladordepeticin'iniciar'fuellamado.");
exec("find/",
{timeout:10000,maxBuffer:20000*1024},
function(error,stdout,stderr){
response.write(stdout);
response.end();
});
}
console.log("Manipuladordepeticin'subir'fuellamado.");
response.end();
}
Esto har que las peticiones HTTP a http://localhost:8888/iniciar tomen al

menos 10 segundos, pero, las peticiones a http://localhost:8888/subir sean
respondidasinmediatamente,inclusosi/iniciartodavaestenproceso.
Sirviendoalgotil
Hasta ahora, lo que hemos hecho es todo simptico y bonito, pero no hemos
creadoanvalorparalosclientesdenuestrositiowebganadordepremios.
Nuestro servidor, router y manipuladores de peticin estn en su lugar, as que

ahora podemos empezar a agregar contenido a nuestro sitio que permitir a
nuestros usuarios interactuar y andar a travs de los casos de uso de elegir un
archivo,subirestearchivo,yverelarchivosubidoenelbrowser.Porsimplicidad
asumiremos que slo los archivos de imagen van a ser subidos y desplegados a
travsdelaaplicacin.
OK,vemoslopasoapaso,peroahora,conlamayoradelastcnicasyprincipios
deJavaScriptexplicadas,acelermoslounpocoalmismotiempo.
Aqu,pasoapasosignificaagrandesrasgosdospasos:vamosaverprimerocomo
manejar peticiones POST entrantes (pero no subidas de archivos), y en un
segundo paso, haremos uso de un modulo externo de Node.js para la
manipulacindesubidadearchivos.Heescogidoestealcancepordosrazones:
Primero, manejar peticiones POST bsicas es relativamente simple con Node.js,

peroannosensealosuficienteparaquevalgalapenaejercitarlo.
Segundo,manejarlassubidasdearchivos(i.e.peticionesPOSTmultiparte)noes
simpleconNode.js,consecuentementeest ms all del alcance de este tutorial,
peroelaprenderausarunmoduloexternoesunaleccinensmismaquetiene
sentidodeserincluidaenuntutorialdeprincipiantes.
ManejandoPeticionesPOST
Mantengamos esto ridculamente simple: presentaremos un rea de texto que
puedaserllenadaporelusuarioyluegoenviadaalservidorenunapeticinPOST.
Unavezrecibidaymanipuladaestapeticin,desplegaremoselcontenidodelrea
detexto.
ElHTMLparaelformulariodeestareadetextonecesitaserservidapornuestro
manipulador de peticin /iniciar, as que agregumoslo de inmediato. En el
archivorequestHandlers.js:
console.log("Manipuladordepeticiones'iniciar'fuellamado.");
varbody='<html>'+
'<head>'+
'<metahttpequiv="ContentType"content="text/html;
charset=UTF8"/>'+
'</head>'+
'<body>'+
'<formaction="/subir"method="post">'+
'<textareaname="text"rows="20"cols="60"></textarea>'+
'<inputtype="submit"value="Enviartexto"/>'+
'</form>'+
'</body>'+
'</html>';
response.write(body);
response.end();
}
console.log("Manipuladordepeticiones'subir'fuellamado.");
response.end();
}
Ahora, si esto no va a ganar los Webby Awards, entonces no se que podra.

Haciendolapeticinhttp://localhost:8888/iniciarentubrowser,deberasverun
formulario muy simple. Si no, entonces probablemente no has reiniciado la
aplicacin.
Teestoyescuchando:tenercontenidodevistajustoenelmanipuladordepeticin
esfeo.Sinembargo,hedecididonoincluiresenivelextradeabstraccin(estoes,
separarlalgicadevistaycontrolador)enestetutorial,yaquepiensoqueesno
nosenseanadaquevalgalapenasaberenelcontextodeJavaScriptoNode.js.
Mejorusemoselespacioquequedaenpantallaparaunproblemamsinteresante,
estoes,manipularlapeticinPOSTquedarconnuestromanipuladordepeticin
/subircuandoelusuarioenveesteformulario.
Ahoraquenosestamosconvirtiendoen"noviciosexpertos",yanonossorprende
el hecho que manipular informacin de POST este hecho de una manera no
bloqueante,medianteelusodellamadasasncronas.
Loquetienesentido,yaquelaspeticionesPOSTpuedenserpotencialmentemuy
grandesnadadetienealusuariodeintroducirtextoquetengamuchosmegabytes
de tamao. Manipular este gran volumen de informacin de una vez puede
resultarenunaoperacinbloqueante.
Parahacerelprocesocompletonobloqueante.Node.jsleentregaanuestrocdigo
la informacin POST en pequeos trozos con callbacks que son llamadas ante
determinados eventos. Estos eventos son data (un nuevo trozo de informacin
POSThallegado)yend(todoslostrozoshansidorecibidos).
Necesitamos decirle a Node.js que funciones llamar de vuelta cuando estos

eventos ocurran. Esto es hecho agregando listeners (N. del T.: del verbo listen
escuchar) al objeto de peticin (request) que es pasado a nuestro callback
onRequestcadavezqueunapeticinHTTPesrecibida.
Estobsicamenteluceas:
request.addListener("data",function(chunk){
//funcionllamadacuandounnuevotrozo(chunk)
//deinformacion(data)esrecibido.
});
request.addListener("end",function(){
//funcionllamadacuandotodoslostrozos(chunks)
//deinformacion(data)hansidorecibidos.
});
Lapreguntaquesurgeesdndeimplementarstalgica.Nosotrosslo podemos
accederalobjetorequestennuestroservidornoseloestamospasandoalrouter
oalosmanipuladoresdepeticin,comolohicimosconelobjetoresponse.
En mi opinin, es un trabajo del servidor HTTP de darle a la aplicacin toda la

informacin de una peticin que necesite para hacer su trabajo. Luego, sugiero
quemanejemoselprocesamientodelapeticindePOSTenelservidormismoy
pasemoslainformacinfinalalrouteryalosmanipuladoresdepeticin,losque
luegodecidirnquehacerconsta.
Entonces,laideaesponerloscallbacksdatayendenelservidor,recogiendotodo
lostrozosdeinformacinPOSTenelcallbackdata,yllamandoalrouterunavez
recibido el evento end, mientras le entregamos los trozos de informacin
recogidosalrouter,elqueasuvezselospasaalosmanipuladoresdepeticin.
Aquvamos,empezandoconserver.js:
vardataPosteada="";
request.setEncoding("utf8");
request.addListener("data",function(trozoPosteado){
dataPosteada+=trozoPosteado;
console.log("RecibidotrozoPOST'"+trozoPosteado+"'.");
});
request.addListener("end",function(){
route(handle,pathname,response,dataPosteada);
});
console.log("ServidorIniciado");
}
Bsicamente hicimos tres cosas aqu: primero, definimos que esperamos que la
codificacin de la informacin recibida sea UTF8, agregamos un listener de
eventos para el evento "data" el cual llena paso a paso nuestra variable
dataPosteada cada vez que un nuevo trozo de informacin POST llega, y
movemoslallamadadesdenuestrorouteralcallbackdeleventoenddemanerade
asegurarnosquesloseallamadocuandotodalainformacinPOSTseareunida.
Adems,pasamoslainformacinPOSTalrouter,yaquelavamosanecesitaren
nuestrosmanipuladoresdeeventos.
Agregarunlogueodeconsolacadavezqueuntrozoesrecibidoesunamalaidea
para cdigo de produccin (megabytes de informacin POST, recuerdan?, pero
tienesentidoparaqueveamosquepasa.
Mejoremos nuestra aplicacin. En la pgina /subir, desplegaremos el contenido

recibido. Para hacer esto posible, necesitamos pasar la dataPosteada a los
manipuladoresdepeticin,enrouter.js.
functionroute(handle,pathname,response,postData){
handle[pathname](response,postData);
}else{
console.log("Nosehaencontradomanipuladorpara"+pathname);
response.write("404Noencontrado");
response.end();
}
}
Y en requestHandlers.js, incluimos la informacin de nuestro manipulador de

peticinsubir:
functioniniciar(response,postData){
console.log("ManipuladordePeticion'iniciar'fuellamado.");
varbody='<html>'+
'<head>'+
charset=UTF8"/>'+
'</head>'+
'<body>'+
'<inputtype="submit"value="Enviartexto"/>'+
'</form>'+
'</body>'+
'</html>';

response.end();
}
functionsubir(response,dataPosteada){
console.log("ManipuladordePeticion'subir'fuellamado.");
response.write("Tuenviaste:"+dataPosteada);
response.end();
}
Eso es, ahora somos capaces de recibir informacin POST y usarla en nuestros
manipuladoresdepeticin.
Una ltima cosa para este tema: lo que le estamos pasando al router y los
manipuladores de peticin es el cuerpo (body) de nuestra peticin POST.
Probablementenecesitemosconsumirloscamposindividualesqueconformanla
informacinPOST,enestecaso,elvalordelcampotext.
Nosotros ya hemos ledo acerca del mdulo querystring, el que nos ayuda con
esto:
varquerystring=require("querystring");
functioniniciar(response,postData){
console.log("Manipuladordepeticion'inicio'fuellamado.");
varbody='<html>'+
'<head>'+
charset=UTF8"/>'+
'</head>'+
'<body>'+
'<inputtype="submit"value="Submittext"/>'+
'</form>'+
'</body>'+
'</html>';
response.end();
}
functionsubir(response,dataPosteada){
response.write("Tuenviasteeltexto::"+
querystring.parse(dataPosteada)["text"]);
response.end();
}
Bueno,parauntutorialdeprincipiantes,estoestodoloquediremosacercadela
informacinPOST.
La prxima vez, hablaremos sobre como usar el excelente mdulo node

formidable para permitirnos lograr nuestro caso de uso final: subir y desplegar
imgenes.
TheNodeBeginnerBookbyManuelKiessling(seeGoogle+profile)islicensedundera
CreativeCommonsAttributionNonCommercialShareAlike3.0UnportedLicense.
Permissionsbeyondthescopeofthislicensemaybeavailableatmanuel@kiessling.net.
Imprint/Impressum/Datenschutz/Haftung

El Libro para Principiantes en Node - Js

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

El Libro para Principiantes en Node - Js

Transféré par

Droits d'auteur :

Formats disponibles

24/2/2017 ElLibroparaPrincipiantesenNode.jsUntutorialcompletodenode.

La cual, por supuesto, no va ser nada como la "aplicacin que va a cambiar el

Enseguida, discutiremos que tipo de "aplicacin del mundo real" queremos

Segn lo prometido, aprenderemos sobre la marcha acerca de algunos de los

No obstante, mantuviste un ojo en JavaScript, y te diste cuenta que con la

Porque ah est el asunto: Ya eres un desarrollador experimentado,ynoquieres

Para ejecutar el cdigo JavaScript que tu pretendes correr en el backend, este

Abre tu editor favorito y crea un archivo llamado holamundo.js. Nosotros

Pensemos un momento acerca de como construiramos esta pila de aplicaciones

Esto te permite tener un archivo main limpio, en el cual ejecutas Node.js, y

Eso es! Acabas de escribir un servidor HTTP activo. Probmoslo ejecutndolo y

Ahora, abre tu browser y apntalo a http://localhost:8888/. Esto debera

Interesante, no? Qu tal si hablamos de que est pasando aqu y dejamos la

Esto hubiese iniciado al servidor HTTP en el puerto 8888 y no hubiese hecho

La parte realmente interesante (y rara, si tu trasfondo es en un lenguaje ms

Resulta que, este definicin de funcin ES el primer (y nico) parmetro que le

Entonces, decir se convierte en la variable local algunaFuncion dentro de

Nosotrospodemos,talcomolohicimos,pasarunafuncinpor su nombre como

De esta manera, no necesitamos darle a la funcin un nombre, por lo que esta

Quizs ahora es un buen momento para preguntar: Por Qu estamos haciendo

(Toma en cuenta que nuestro servidor probablemente escribir "Peticin

Cuando la callback es disparada y nuestra funcin onRequest() es gatillada, dos

Por ahora, la funcionalidad que nuestro servidor HTTP necesita exportar es

Podemos, por supuesto, tambin utilizar querystring para parsear el cuerpo de

Agreguemos ahora a nuestra funcin onRequest() la lgica requerida para

En el contexto de nuestra aplicacin, esto significa simplemente que seremos

Pasar funciones no es slo una consideracin tcnica. Con respecto al diseo de

Peroelservidornonecesitalacosa.Slonecesitahaceralgo,y para que algo se

Entender este cambio de mentalidad fundamental que est en el ncleo de esta

Por supuesto, esto no es suficiente, "Rutear" significa que nosotros queremos

Llamemos a estas funciones, donde las peticiones estn siendo ruteadas,

En C++ o C#, cuando hablamos acerca de objetos, nos estamos

colecciones de pares nombre/valor piensa en un objeto JavaScript

Si los objetos JavaScript son slo colecciones de pares nombre/valor, Cmo

Como puedes ver, es realmente simple mapear diferentes URLs al mismo

"Manipular Peticiones" no significa otra cosa que "Responder a las Peticiones"

A lo que me refiero con "aproximacin directa" es esto: hacer que los

Empecemos con los manipuladores de peticin y hagmoslos retornar, lo que

Bien. De todas maneras, el router necesita retornar al servidor lo que los

http://localhost:8888/subir nos da "Hola Subir", y la peticin a

Y, en vez de intentar explicar que es lo que significa "bloqueante" y "no

Para hacer esto, modificaremos nuestro manipulador de peticin iniciar para

En la barra de direcciones de la segunda ventana de browser, ingresa

Ahora, haz lo siguiente: presiona enter en la primera ventana ("/iniciar"), luego,

He ah el problema, porque, el dicho es: "En Node.js, todo corre en paralelo,

Lo que eso significa es que Node.js puede manejar un montn de temas

Como siempre, arrancaremos nuestra aplicacin y visitaremos

Bueno, como ya habrn adivinado, exec() hace su magia de una manera no

Pero no estaramos muy felices si nuestra elegante aplicacin no bloqueante no

Y aqu yace la raz de nuestro problema: nuestro cdigo es ejecutado de manera

Bueno, despus de aprender como no hacerlo, discutamos cmo hacer que

Ahora mismo, nuestra aplicacin es capaz de transportar el contenido desde los

Nuestro nuevo enfoque es como sigue: en vez de llevar el contenido al servidor,

En vez de esperar un valor de respuesta desde la funcin route(), pasmosle un

Mismo patrn: En vez de esperar que retorne un valor desde nuestros

Si no hay manipulador de peticin para utilizar, ahora nos hacemos cargo de

Y por ltimo, pero no menos importante, modificamos a requestHandlers.js (el

Nuestras funciones manipuladoras necesitan aceptar el parmetro de respuesta

El manipulador iniciar responder con el callback annimo exec(), y el

Si quieres probar que la operacin cara dentro de /iniciar no bloquear ms las

Esto har que las peticiones HTTP a http://localhost:8888/iniciar tomen al

Nuestro servidor, router y manipuladores de peticin estn en su lugar, as que

Primero, manejar peticiones POST bsicas es relativamente simple con Node.js,