UNIDAD 3 PROGRAMACION NODEJS
Alexander Benavides Acuña
Universidad de Cartagena
2023
Contenido
1. Descripción...................................................................................................................... 4
2. Tema 1: Introducción ...................................................................................................... 5
1.1 ¿Qué son los Koans?..................................................................................................... 5
1.2 Guía de lectura .............................................................................................................. 5
1.3 Conseguir el código fuente ........................................................................................... 5
3. Tema 2: Introducción a Node v0.8 .................................................................................. 6
2.1 ¿Qué es Node? .............................................................................................................. 6
2.2 "Es una plataforma" ...................................................................................................... 6
2.2.1 El proceso de arranque de Node ............................................................................ 6
2.2.2 El formato CommonJS .......................................................................................... 6
2.2.3 Módulos disponibles en el core de Node ............................................................... 6
2.2.4 Módulos de terceras partes .................................................................................... 7
2.3 "Construida encima del entorno de ejecución de JavaScript de Chrome".................... 7
2.3.1 El lenguaje JavaScript ........................................................................................... 7
2.3.2 El motor V8 de Google .......................................................................................... 7
2.4 "Fácil desarrollo de rápidas, escalables aplicaciones de red" ....................................... 7
2.5 "Usa E/S no bloqueante dirigida por eventos" ............................................................. 8
2.5.1 El modelo de Concurrencia de Node ..................................................................... 8
2.5.2 Arquitectura de Node............................................................................................. 8
2.5.3 La clase EventEmitter ............................................................................................ 8
2.5.4 Postponiendo la ejecución de funciones ................................................................ 9
2.6 "Es ligero y eficiente" ................................................................................................... 9
2.7 "Perfecto para aplicaciones en tiempo real data-intensive" .......................................... 9
2.7.1 Tiempo real y Node ............................................................................................... 9
2.7.2 ¿Para qué es útil Node entonces? .......................................................................... 9
4. Tema 3: Módulos Buffer y Dgram .................................................................................. 9
3.1 Aspectos de UDP relevantes para Node ....................................................................... 9
3.2 UDP en Node .............................................................................................................. 10
3.3 Codificación de caracteres .......................................................................................... 10
3.4 Buffers en JavaScript .................................................................................................. 10
3.5 Aplicación con Buffers y UDP ................................................................................... 10
3.5.1 Descripción del problema .................................................................................... 10
3.5.2 Diseño propuesto ................................................................................................. 11
3.6 Objetivos de los Koans ............................................................................................... 11
3.7 Preparación del entorno y ejecución de los Koans ..................................................... 11
5. Tema 4: Módulos Stream y Net .................................................................................... 11
4.1 Aspectos de TCP relevantes para Node ...................................................................... 11
4.2 Streams en Node ......................................................................................................... 12
4.3 TCP en Node .............................................................................................................. 12
4.4 Aplicación con Streams TCP...................................................................................... 12
4.4.1 Descripción del problema .................................................................................... 12
4.4.2 Diseño propuesto ................................................................................................. 12
4.5 Objetivos de los Koans ............................................................................................... 12
4.6 Preparación del entorno y ejecución de los Koans ..................................................... 13
6. Tema 5: Módulo HTTP ................................................................................................. 13
5.1 Aspectos de HTTP relevantes para Node ................................................................... 13
5.1.1 La parte del Cliente.............................................................................................. 13
5.1.2 La parte del Servidor ........................................................................................... 13
5.2 HTTP en Node ............................................................................................................ 13
5.2.1 ServerRequest ...................................................................................................... 14
5.2.2 ServerResponse ................................................................................................... 14
5.2.3 Clientes HTTP ......................................................................................................... 14
5.2.4 ClientResponse .................................................................................................... 14
5.3 Aplicación con HTTP ................................................................................................. 15
5.3.1 Descripción del problema .................................................................................... 15
5.3.2 Diseño propuesto ................................................................................................. 15
5.4 Objetivos de los Koans ............................................................................................... 15
5.5 Preparación del entorno y ejecución de los Koans ..................................................... 15
1. Descripción
El módulo "Koans de [Link]" es un recurso educativo que tiene como objetivo proporcionar
una forma interactiva y práctica de aprender [Link]. Los Koans son ejercicios autónomos y
guiados que presentan desafíos relacionados con diferentes aspectos de [Link] y su
ecosistema de módulos. Cada Koan presenta un problema o concepto específico y guía al
estudiante a través de pasos para resolverlo, fomentando la comprensión y el aprendizaje
activo.
Objetivo
El objetivo principal de los Koans de [Link] es ayudar a los estudiantes a familiarizarse con
los conceptos fundamentales de [Link] y fortalecer su comprensión práctica de cómo usar
eficientemente este entorno de ejecución de JavaScript. Al completar los Koans, los
estudiantes adquieren conocimientos sobre los módulos esenciales de [Link], como Buffer,
Dgram, Stream, Net y HTTP, y se familiarizan con su aplicación en situaciones del mundo
real.
2. Tema 1: Introducción
1.1 ¿Qué son los Koans?
Los Koans son pequeños ejercicios o problemas que se utilizan para aprender y practicar
conceptos y técnicas de programación en [Link]. Los Koans están diseñados para fomentar
el pensamiento crítico y la resolución de problemas, y suelen requerir que el estudiante
complete o arregle el código existente para que funcione correctamente. Los Koans se centran
en aspectos específicos de [Link] y pueden cubrir temas como manejo de eventos, uso de
módulos, operaciones de red y comunicación de datos.
1.2 Guía de lectura
Antes de comenzar con los Koans, es recomendable tener conocimientos básicos de
JavaScript y familiarizarse con los conceptos fundamentales de [Link]. Se recomienda leer
la documentación oficial de [Link] para comprender mejor las características y
funcionalidades del entorno. Al enfrentarse a un Koan, es importante leer cuidadosamente
las instrucciones y los comentarios en el código proporcionado. Se debe practicar la
resolución de los Koans de forma incremental, comenzando por los más simples y avanzando
hacia los más complejos.
1.3 Conseguir el código fuente
El código fuente de los Koans se puede obtener desde el repositorio oficial en GitHub.
Se proporcionarán instrucciones sobre cómo descargar o clonar el repositorio en el entorno
de desarrollo local.
3. Tema 2: Introducción a Node v0.8
2.1 ¿Qué es Node?
[Link] es un entorno de tiempo de ejecución de JavaScript que permite ejecutar código
JavaScript en el servidor. [Link] utiliza el motor V8 de Google Chrome para interpretar y
ejecutar el código JavaScript. [Link] proporciona un conjunto de módulos y bibliotecas que
facilitan el desarrollo de aplicaciones web y de red.
2.2 "Es una plataforma"
2.2.1 El proceso de arranque de Node
- Cuando se ejecuta una aplicación [Link], el proceso de arranque implica la inicialización
del entorno y la carga de los módulos necesarios.
- [Link] utiliza un archivo de entrada principal (por lo general, con extensión .js) para iniciar
la aplicación.
- El proceso de arranque incluye la configuración de variables de entorno, la carga de
módulos requeridos y la ejecución del código principal de la aplicación.
2.2.2 El formato CommonJS
- [Link] utiliza el formato de módulos CommonJS, que permite la encapsulación de código
en módulos reutilizables.
- En el formato CommonJS, cada archivo JavaScript es tratado como un módulo
independiente con su propio ámbito y contexto.
- Los módulos pueden exportar funciones, objetos o valores que pueden ser utilizados por
otros módulos mediante el uso de la palabra clave [Link].
2.2.3 Módulos disponibles en el core de Node
- El core de [Link] incluye un conjunto de módulos internos que proporcionan
funcionalidades básicas y comunes.
- Estos módulos internos están disponibles de forma predeterminada en [Link] sin necesidad
de instalar paquetes adicionales.
- Algunos ejemplos de módulos del core de [Link] son fs (sistema de archivos), http
(protocolo HTTP), path (manipulación de rutas de archivos) y util (utilidades generales).
2.2.4 Módulos de terceras partes
- Además de los módulos internos, [Link] permite la instalación y uso de módulos de
terceras partes.
- Estos módulos se pueden encontrar en el registro de paquetes de [Link] (NPM) y se pueden
instalar utilizando el gestor de paquetes npm.
- Los módulos de terceras partes amplían las funcionalidades de [Link] y pueden abarcar
desde herramientas de desarrollo hasta frameworks y bibliotecas específicas.
2.3 "Construida encima del entorno de ejecución de JavaScript de Chrome"
2.3.1 El lenguaje JavaScript
- JavaScript es un lenguaje de programación de alto nivel y orientado a objetos ampliamente
utilizado en el desarrollo web.
- [Link] utiliza el lenguaje JavaScript como base para desarrollar aplicaciones en el entorno
del servidor.
- Los conocimientos básicos de JavaScript son fundamentales para trabajar con [Link] y
comprender su sintaxis y características.
2.3.2 El motor V8 de Google
- El motor V8 es un motor de JavaScript de código abierto desarrollado por Google.
- V8 es utilizado por [Link] para compilar y ejecutar el código JavaScript.
- V8 está diseñado para ser rápido y eficiente, y utiliza técnicas avanzadas como la
compilación JIT (Just-In-Time) para mejorar el rendimiento de la ejecución del código.
2.4 "Fácil desarrollo de rápidas, escalables aplicaciones de red"
[Link] está diseñado para facilitar el desarrollo de aplicaciones de red eficientes y
escalables.
La arquitectura de E/S no bloqueante y dirigida por eventos de [Link] permite manejar
múltiples conexiones simultáneamente sin bloquear el hilo principal de ejecución.
Esto hace que [Link] sea especialmente adecuado para aplicaciones que requieren una gran
cantidad de operaciones de red, como servidores web en tiempo real, aplicaciones de chat y
aplicaciones de transmisión de datos.
2.5 "Usa E/S no bloqueante dirigida por eventos"
2.5.1 El modelo de Concurrencia de Node
- El modelo de concurrencia de [Link] se basa en el uso de E/S no bloqueante y dirigida por
eventos.
- En lugar de esperar a que una operación de E/S se complete antes de continuar con la
siguiente, [Link] utiliza devoluciones de llamada (callbacks) para manejar eventos y realizar
operaciones de forma asíncrona.
- Esto permite que el hilo principal de ejecución esté disponible para manejar otras solicitudes
mientras espera la finalización de las operaciones de E/S.
2.5.2 Arquitectura de Node
- La arquitectura de [Link] está basada en el patrón de diseño de eventos y se centra en el
manejo eficiente de eventos y la emisión de señales.
- [Link] utiliza una estructura de bucle de eventos para escuchar y responder a eventos de
forma asíncrona.
- Los eventos en [Link] se pueden emitir desde el propio entorno de [Link], así como desde
los módulos y aplicaciones personalizadas.
2.5.3 La clase EventEmitter
- La clase EventEmitter es una parte fundamental de la arquitectura de [Link].
- Permite la emisión y escucha de eventos personalizados en [Link].
- Los objetos que heredan de EventEmitter pueden emitir eventos y registrar devoluciones de
llamada (callbacks) para manejar esos eventos.
2.5.4 Postponiendo la ejecución de funciones
- [Link] permite la ejecución de funciones de forma asíncrona utilizando devoluciones de
llamada y promesas.
- Esto evita bloquear el hilo principal de ejecución y permite un mejor rendimiento y
capacidad de respuesta en aplicaciones con operaciones de E/S intensivas.
2.6 "Es ligero y eficiente"
[Link] está diseñado para ser ligero y eficiente en términos de uso de recursos de hardware
y memoria. La arquitectura de eventos y el enfoque no bloqueante de [Link] permiten un
mejor aprovechamiento de los recursos disponibles. [Link] puede manejar grandes
cantidades de solicitudes concurrentes sin requerir una gran cantidad de recursos del sistema.
2.7 "Perfecto para aplicaciones en tiempo real data-intensive"
2.7.1 Tiempo real y Node
- [Link] es particularmente adecuado para aplicaciones en tiempo real que requieren una
comunicación bidireccional instantánea entre el servidor y el cliente.
- Esto incluye aplicaciones de chat en tiempo real, juegos en línea, sistemas de colaboración
y otras aplicaciones que dependen de la transmisión de datos en tiempo real.
2.7.2 ¿Para qué es útil Node entonces?
- [Link] es útil en una amplia gama de aplicaciones, desde pequeños proyectos hasta grandes
sistemas empresariales.
- Algunos casos de uso comunes de [Link] incluyen el desarrollo de servidores web, API
RESTful, aplicaciones de tiempo real, aplicaciones de Internet de las cosas (IoT) y
aplicaciones de transmisión de datos en tiempo real.
4. Tema 3: Módulos Buffer y Dgram
3.1 Aspectos de UDP relevantes para Node
UDP (User Datagram Protocol) es un protocolo de comunicación orientado a conexión que
se utiliza para la transmisión de datos en redes IP. En [Link], es importante comprender los
aspectos fundamentales de UDP, como la comunicación de datagramas y las características
de conexión no garantizadas.
3.2 UDP en Node
[Link] proporciona un módulo dgram que permite la creación y manipulación de sockets
UDP para la comunicación de red. Con el módulo dgram, es posible enviar y recibir
datagramas UDP, establecer opciones de socket y manejar eventos relacionados con la
comunicación UDP.
3.3 Codificación de caracteres
En la comunicación de datos, especialmente en el contexto de redes y protocolos, es esencial
comprender cómo se codifican y decodifican los caracteres.
[Link] proporciona funcionalidades para la codificación y decodificación de caracteres en
diferentes formatos, como UTF-8 o ASCII.
3.4 Buffers en JavaScript
En JavaScript, un Buffer es una estructura de datos utilizada para almacenar y manipular
secuencias de bytes. Los Buffers son útiles cuando se trabaja con datos binarios o cuando se
necesita realizar operaciones de E/S en bruto.
3.5 Aplicación con Buffers y UDP
3.5.1 Descripción del problema
- En este contexto, se describe un problema específico relacionado con la transmisión de
datos utilizando UDP y la manipulación de buffers en [Link].
- El problema puede implicar la recepción y envío de datagramas UDP, la manipulación y
transformación de datos utilizando buffers y la implementación de un protocolo específico.
3.5.2 Diseño propuesto
- Se proporciona un diseño propuesto para abordar el problema mencionado anteriormente.
- El diseño puede incluir la definición de estructuras de datos, algoritmos de manipulación
de buffers, implementación de lógica de red y cualquier otro aspecto relevante.
3.6 Objetivos de los Koans
Los objetivos de los Koans en este contexto son proporcionar una forma práctica de aprender
y practicar el uso de los módulos Buffer y Dgram en [Link].
Los Koans pueden incluir ejercicios que cubran diferentes aspectos de los módulos, como la
creación y manipulación de buffers, la configuración de sockets UDP y la implementación
de lógica de red.
3.7 Preparación del entorno y ejecución de los Koans
Se proporcionarán instrucciones detalladas sobre cómo configurar el entorno de desarrollo
para ejecutar los Koans. Esto puede incluir la instalación de [Link], la configuración de
dependencias y cualquier otro requisito específico para ejecutar los ejercicios correctamente.
5. Tema 4: Módulos Stream y Net
4.1 Aspectos de TCP relevantes para Node
TCP (Transmission Control Protocol) es un protocolo de comunicación orientado a la
conexión utilizado para la transmisión confiable de datos en redes IP.
En [Link], es importante comprender los aspectos fundamentales de TCP, como el
establecimiento de conexiones, el envío y recepción de datos y el manejo de eventos
relacionados con la comunicación TCP.
4.2 Streams en Node
[Link] proporciona el módulo stream, que permite la manipulación eficiente de secuencias
de datos. Los streams son una abstracción que permite la lectura y escritura de datos en
pequeños fragmentos, en lugar de procesar todo el conjunto de datos de una vez. Los streams
son útiles para manipular grandes volúmenes de datos o para la transmisión de datos en
tiempo real.
4.3 TCP en Node
[Link] proporciona el módulo net, que permite la creación y manipulación de sockets TCP
para la comunicación de red.
Con el módulo net, es posible establecer conexiones TCP, enviar y recibir datos a través de
esas conexiones, y manejar eventos relacionados con la comunicación TCP.
4.4 Aplicación con Streams TCP
4.4.1 Descripción del problema
- En este contexto, se describe un problema específico relacionado con la transmisión de
datos utilizando TCP y la manipulación de streams en [Link].
- El problema puede implicar la implementación de un servidor TCP que acepte conexiones
entrantes, procese y envíe datos utilizando streams, y maneje eventos de comunicación.
4.4.2 Diseño propuesto
- Se proporciona un diseño propuesto para abordar el problema mencionado anteriormente.
- El diseño puede incluir la definición de la estructura del servidor, la configuración de los
streams de entrada y salida, la implementación de la lógica de procesamiento de datos y
cualquier otro aspecto relevante.
4.5 Objetivos de los Koans
Los objetivos de los Koans en este contexto son proporcionar una forma práctica de aprender
y practicar el uso de los módulos Stream y Net en [Link]. Los Koans pueden incluir
ejercicios que cubran diferentes aspectos de los módulos, como la creación y manipulación
de streams, el establecimiento de conexiones TCP, la transmisión de datos y la
implementación de lógica de red.
4.6 Preparación del entorno y ejecución de los Koans
Se proporcionarán instrucciones detalladas sobre cómo configurar el entorno de desarrollo
para ejecutar los Koans.
Esto puede incluir la instalación de [Link], la configuración de dependencias y cualquier
otro requisito específico para ejecutar los ejercicios correctamente.
6. Tema 5: Módulo HTTP
5.1 Aspectos de HTTP relevantes para Node
5.1.1 La parte del Cliente
- En el contexto de [Link], es importante comprender los aspectos relevantes del protocolo
HTTP en el contexto del cliente.
- Esto incluye la realización de solicitudes HTTP, el manejo de respuestas, el procesamiento
de encabezados y el envío de datos al servidor.
5.1.2 La parte del Servidor
- En el contexto de [Link], es importante comprender los aspectos relevantes del protocolo
HTTP en el contexto del servidor.
- Esto incluye la creación de un servidor HTTP, la gestión de solicitudes entrantes, la
generación de respuestas y el enrutamiento de solicitudes a controladores adecuados.
5.2 HTTP en Node
[Link] proporciona el módulo http que permite la creación y manipulación de servidores y
clientes HTTP. Con el módulo http, es posible realizar solicitudes HTTP y crear servidores
HTTP para recibir y procesar solicitudes entrantes.
5.2.1 ServerRequest
El objeto ServerRequest es una representación de una solicitud entrante en un servidor HTTP
de [Link]. Contiene información sobre la solicitud, como la URL, los encabezados y el
cuerpo.
5.2.2 ServerResponse
El objeto ServerResponse es una representación de la respuesta que se enviará desde un
servidor HTTP de [Link]. Permite configurar encabezados, escribir datos de respuesta y
enviar la respuesta al cliente.
5.2.3 Clientes HTTP
En [Link], es posible realizar solicitudes HTTP salientes desde el cliente utilizando el
módulo http. Esto permite interactuar con servidores HTTP externos, enviar solicitudes,
recibir respuestas y procesar los datos recibidos.
5.2.4 ClientResponse
El objeto ClientResponse es una representación de la respuesta recibida desde un servidor
HTTP externo en un cliente HTTP de [Link]. Contiene información sobre la respuesta,
como los encabezados y el cuerpo de la respuesta.
5.3 Aplicación con HTTP
5.3.1 Descripción del problema
- En este contexto, se describe un problema específico relacionado con la creación de un
servidor HTTP y la interacción con clientes HTTP utilizando el módulo http en [Link].
- El problema puede implicar la implementación de rutas, el procesamiento de solicitudes
entrantes y el envío de respuestas adecuadas a los clientes.
5.3.2 Diseño propuesto
- Se proporciona un diseño propuesto para abordar el problema mencionado anteriormente.
- El diseño puede incluir la definición de rutas, la configuración del servidor HTTP, la
implementación de controladores de ruta y cualquier otro aspecto relevante.
5.4 Objetivos de los Koans
Los objetivos de los Koans en este contexto son proporcionar una forma práctica de aprender
y practicar el uso del módulo HTTP en [Link].
Los Koans pueden incluir ejercicios que cubran diferentes aspectos del módulo, como la
creación de servidores HTTP, la gestión de solicitudes y respuestas, el enrutamiento y la
interacción con clientes HTTP.
5.5 Preparación del entorno y ejecución de los Koans
Se proporcionarán instrucciones detalladas sobre cómo configurar el entorno de desarrollo
para ejecutar los Koans. Esto puede incluir la instalación de [Link], la configuración de
dependencias y cualquier otro requisito específico para ejecutar los ejercicios correctamente.
Referencias
De la Torre Monzón Arturo Muñoz(2014), Introducción a [Link] a través de Koans
Recuperado de: [Link]