La programación basada en eventos puede ser abrumadora para los principiantes, lo que puede dificultar el comienzo de Node.js. Pero no dejes que eso te desanime; En este artículo, te enseñaré algunos de los conceptos básicos de Node.js y explicaré por qué se ha vuelto tan popular.
Si necesita ayuda, siempre puede contactar a uno de los expertos en JavaScript de Envato Studio. Ya sea que necesite corregir un error o agregar una nueva característica, encontrará un desarrollador experimentado de JavaScript para ayudarlo.
Introducción
Para comenzar a usar Node.js, primero debe comprender las diferencias entre Node.js y los entornos de secuencias de comandos tradicionales del lado del servidor (por ejemplo: PHP, Python, Ruby, etc.).
Programación asincrónica
Node.js utiliza una arquitectura de módulo para simplificar la creación de aplicaciones complejas.
Es probable que esté familiarizado con la programación asincrónica; es, después de todo, la “A” en Ajax. Cada función en Node.js es asíncrona. Por lo tanto, todo lo que normalmente bloquearía el hilo se ejecuta en segundo plano. Esto es lo más importante para recordar sobre Node.js. Por ejemplo, si está leyendo un archivo en el sistema de archivos, debe especificar una función de devolución de llamada que se ejecuta cuando se completa la operación de lectura.
¡Estás haciendo todo!
Node.js es solo un entorno, lo que significa que debe hacer todo usted mismo. No hay un servidor HTTP predeterminado, ni ningún servidor para el caso. Esto puede ser abrumador para los nuevos usuarios, pero la recompensa es una aplicación web de alto rendimiento. Un script maneja toda la comunicación con los clientes. Esto reduce considerablemente la cantidad de recursos utilizados por la aplicación. Por ejemplo, aquí está el código para una aplicación Node.js simple:
var i, a, b, c, max;
max = 1000000000;
var d = Date.now ();
para (i = 0; i a = 1234 + 5678 + i;
b = 1234 * 5678 + i;
c = 1234/2 + i;
}
console.log (Date.now () – d);
Y aquí está el equivalente escrito en PHP:
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
$a = null;
$b = null;
$c = null;
$i = null;
$max = 1000000000;
$start = microtime(true);
for ($i = 0; $i < $max; $i++) {
$a = 1234 + 5678 + $i;
$b = 1234 * 5678 + $i;
$c = 1234 / 2 + $i;
}
var_dump(microtime(true) - $start);
Ahora veamos los números de referencia. La siguiente tabla enumera los tiempos de respuesta, en milisegundos, para estas dos aplicaciones simples:
Numero de iteraciones
Node.js
PHP
100
2,00
0,14
10'000
3.00
10,53
1'000'000
15.00
1119,24
10'000'000
143,00
10621,46
1'000'000'000
11118.00
1036272.19
Ejecuté las dos aplicaciones desde la línea de comandos para que ningún servidor retrasara la ejecución de las aplicaciones. Realicé cada prueba diez veces y promedié los resultados. PHP es notablemente más rápido con una menor cantidad de iteraciones, pero esa ventaja se disuelve rápidamente a medida que aumenta el número de iteraciones. Cuando todo está dicho y hecho, ¡PHP es 93% más lento que Node.js!
Node.js es rápido, pero necesitará aprender algunas cosas para poder usarlo correctamente.
Módulos
Node.js utiliza una arquitectura de módulo para simplificar la creación de aplicaciones complejas. Los módulos son similares a las bibliotecas en C, o las unidades en Pascal. Cada módulo contiene un conjunto de funciones relacionadas con el "sujeto" del módulo. Por ejemplo, el módulo http contiene funciones específicas de HTTP. Node.js proporciona algunos módulos básicos listos para usar para ayudarlo a acceder a los archivos en el sistema de archivos, crear servidores HTTP y TCP / UDP y realizar otras funciones útiles.
Incluir un módulo es fácil; simplemente llame a la función require() , así:
var http = require ('http');
Node.js es solo un entorno; Tienes que hacer todo tú mismo.
La función require() devuelve la referencia al módulo especificado. En el caso de este código, una referencia al módulo http se almacena en la variable http .
En el código anterior, pasamos el nombre de un módulo a la función require() . Esto hace que Node busque una carpeta node_modules en el directorio de nuestra aplicación y busque el módulo http en esa carpeta. Si Node no encuentra la carpeta node_modules (o el módulo http dentro de ella), busca a través de la memoria caché global del módulo. También puede especificar un archivo real pasando una ruta relativa o absoluta, así:
var myModule = require ('./ myModule.js');
Los módulos son piezas de código encapsuladas. El código dentro de un módulo es principalmente privado, lo que significa que las funciones y variables definidas dentro de ellas solo son accesibles desde el interior del módulo. Sin embargo, puede exponer funciones y / o variables que se utilizarán fuera del módulo. Para hacerlo, use el objeto de exports y complete sus propiedades y métodos con las piezas de código que desea exponer. Considere el siguiente módulo como ejemplo:
var PI = Math.PI;
exportaciones.area = función (r) {
devolver PI * r * r;
};
exportaciones.circunferencia = función (r) {
devuelve 2 * PI * r;
};
Este código crea una variable PI que solo se puede acceder mediante el código contenido en el módulo; No es accesible fuera del módulo. A continuación, se crean dos funciones en el objeto de exports . Se puede acceder a estas funciones fuera del módulo porque están definidas en el objeto de exports . Como resultado, PI está completamente protegido de la interferencia externa. Por lo tanto, puede estar seguro de que area() y circumference() siempre se comportarán como deberían (siempre que se proporcione un valor para el parámetro r ).
Alcance global
Node es un entorno JavaScript que se ejecuta en el motor JavaScript V8 de Google. Como tal, debemos seguir las mejores prácticas que utilizamos para el desarrollo del lado del cliente. Por ejemplo, debemos evitar poner algo en el alcance global. Eso, sin embargo, no siempre es posible. El alcance global en Node es GLOBAL (a diferencia de la window en el navegador), y puede crear fácilmente una variable global de función omitiendo la palabra clave var , como esta:
globalVariable = 1;
globalFunction = function () {…};
Una vez más, se deben evitar los globales cuando sea posible. Así que tenga cuidado y recuerde usar var al declarar una variable.
Instalación
Naturalmente, necesitamos instalar Node antes de poder escribir y ejecutar una aplicación. La instalación es sencilla, si usa Windows u OS X; El sitio web nodejs.org ofrece instaladores para esos sistemas operativos. Para Linux, use cualquier administrador de paquetes. Abre tu terminal y escribe:
sudo apt-get update
sudo apt-get install node
o:
actualización de aptitud sudo
nodo de instalación de sudo aptitude
Node.js está en repositorios sid; Es posible que deba agregarlos a su lista de fuentes:
sudo echo deb http://ftp.us.debian.org/debian/ sid main> /etc/apt/sources.list.d/sid.list
Pero tenga en cuenta que la instalación de paquetes sid en sistemas más antiguos puede dañar su sistema. Tenga cuidado y elimine /etc/apt/sources.list.d/sid.list después de que termine de instalar Node.
Instalar nuevos módulos
Node.js tiene un administrador de paquetes, llamado Node Package Manager (NPM). Se instala automáticamente con Node.js, y usa NPM para instalar nuevos módulos. Para instalar un módulo, abra su terminal / línea de comando, navegue a la carpeta deseada y ejecute el siguiente comando:
npm install module_name
No importa qué sistema operativo tenga; el comando anterior instalará el módulo que especifique en lugar de module_name .
La aplicación Hello World
Naturalmente, nuestro primer script Node.js imprimirá el texto 'Hello World!' a la consola Cree un archivo llamado hello.js y escriba el siguiente código:
console.log ('¡Hola, mundo!');
Ahora ejecutemos el script. Abra la línea de terminal / comando, navegue a la carpeta que contiene hello.js y ejecute el siguiente comando:
nodo hello.js
Deberías ver 'Hello World!' mostrado en la consola.
Servidor HTTP
Pasemos a una aplicación más avanzada; No es tan complicado como puede pensar. Comencemos con el siguiente código. Lea los comentarios y luego la explicación a continuación:
// Incluye módulo http.
var http = require ("http");
// Crea el servidor. La función pasada como parámetro se llama en cada solicitud realizada.
// variable de solicitud contiene todos los parámetros de solicitud
// la variable de respuesta le permite hacer cualquier cosa con la respuesta enviada al cliente.
http.createServer (función (solicitud, respuesta) {
// Adjuntar escucha en el evento final.
// Este evento se llama cuando el cliente envió todos los datos y está esperando respuesta.
request.on ("fin", función () {
// Escribe encabezados para la respuesta.
// 200 es el código de estado HTTP (este significa éxito)
// El segundo parámetro contiene campos de encabezado en el objeto
// Estamos enviando texto sin formato, por lo que Content-Type debe ser text / plain
response.writeHead (200, {
'Content-Type': 'text / plain'
});
// Enviar datos y finalizar la respuesta.
response.end ('¡Hola HTTP!');
});
// Escucha en el puerto 8080.
}). escuchar (8080);
Este código es muy simple. Puede enviar más datos al cliente utilizando el método response.write() , pero debe llamarlo antes de llamar a response.end() . Guarde este código como http.js y escríbalo en su consola:
nodo http.js
Abra su navegador y navegue a http://localhost:8080 . Debería ver el texto "¡Hola HTTP!" en la pagina
Manejo de parámetros de URL
Como mencioné anteriormente, tenemos que hacer todo nosotros mismos en Node, incluidos los argumentos de solicitud de análisis. Esto es, sin embargo, bastante simple. Echa un vistazo al siguiente código:
// Incluir módulo http,
var http = require ("http"),
// Y el módulo url, que es muy útil para analizar parámetros de solicitud.
url = require ("url");
// Crea el servidor.
http.createServer (función (solicitud, respuesta) {
// Adjuntar escucha al evento final.
request.on ('fin', función () {
// Analiza la solicitud de argumentos y los almacena en la variable _get.
// Esta función analiza la url de la solicitud y devuelve la representación del objeto.
var _get = url.parse (request.url, true) .query;
// Escribe encabezados para la respuesta.
response.writeHead (200, {
'Content-Type': 'text / plain'
});
// Enviar datos y finalizar la respuesta.
response.end ('Aquí están sus datos:' + _get ['datos']);
});
// Escucha en el puerto 8080.
}). escuchar (8080);
Este código utiliza el método parse() del módulo url , un módulo central Node.js, para convertir la URL de la solicitud en un objeto. El objeto devuelto tiene una propiedad de query , que recupera los parámetros de la URL. Guarde este archivo como get.js y ejecútelo con el siguiente comando:
nodo get.js
Luego, navegue a http://localhost:8080/?data=put_some_text_here en su navegador. Naturalmente, cambiar el valor del parámetro de data no interrumpirá el script.
Leer y escribir archivos
Para administrar archivos en Node, usamos el módulo fs (un módulo central). Leemos y escribimos archivos usando los fs.readFile() y fs.writeFile() , respectivamente. Explicaré los argumentos después del siguiente código:
// Incluir módulo http,
var http = require ("http"),
// Y el módulo mysql que acabas de instalar.
fs = require ("fs");
// Crea el servidor http.
http.createServer (función (solicitud, respuesta) {
// Adjuntar escucha al evento final.
request.on ("fin", función () {
// Lee el archivo.
fs.readFile ("test.txt", 'utf-8', función (error, datos) {
// Escribe encabezados.
response.writeHead (200, {
'Content-Type': 'text / plain'
});
// Incrementa el número obtenido del archivo.
datos = parseInt (datos) + 1;
// Escribe un número incrementado en el archivo.
fs.writeFile ('test.txt', datos);
// Finaliza la respuesta con un buen mensaje.
response.end ('¡Esta página se actualizó' + datos + 'veces!');
});
});
// Escucha en el puerto 8080.
}). escuchar (8080);
Node.js tiene un administrador de paquetes, llamado Node Package Manager (NPM). Se instala automáticamente con Node.js
Guarde esto como files.js . Antes de ejecutar este script, cree un archivo llamado test.txt en el mismo directorio que files.js .
Este código muestra los fs.readFile() y fs.writeFile() . Cada vez que el servidor recibe una solicitud, el script lee un número del archivo, incrementa el número y escribe el nuevo número en el archivo. El método fs.readFile() acepta tres argumentos: el nombre del archivo a leer, la codificación esperada y la función de devolución de llamada.
Escribir en el archivo, al menos en este caso, es mucho más simple. No necesitamos esperar ningún resultado, aunque verificaría si hay errores en una aplicación real. El método fs.writeFile() acepta el nombre del archivo y los datos como argumentos. También acepta argumentos tercero y cuarto (ambos son opcionales) para especificar la codificación y la función de devolución de llamada, respectivamente.
Ahora, ejecutemos este script con el siguiente comando:
nodo files.js
Ábralo en el navegador ( http://localhost:8080 ) y actualícelo varias veces. Ahora, puede pensar que hay un error en el código porque parece incrementarse en dos. Esto no es un error. Cada vez que solicita esta URL, se envían dos solicitudes al servidor. La primera solicitud la realiza automáticamente el navegador, que solicita favicon.ico y, por supuesto, la segunda solicitud es para la URL ( http://localhost:8080 ).
Aunque técnicamente este comportamiento no es un error, es un comportamiento que no queremos. Podemos solucionar esto fácilmente verificando la URL de solicitud. Aquí está el código revisado:
// Incluir módulo http,
var http = require ("http"),
// Y el módulo mysql que acabas de instalar.
fs = require ("fs");
// Crea el servidor http.
http.createServer (función (solicitud, respuesta) {
// Adjuntar escucha al evento final.
request.on ('fin', función () {
// Comprobar si el usuario solicita /
if (request.url == '/') {
// Lee el archivo.
fs.readFile ('test.txt', 'utf-8', función (error, datos) {
// Escribe encabezados.
response.writeHead (200, {
'Content-Type': 'text / plain'
});
// Incrementa el número obtenido del archivo.
datos = parseInt (datos) + 1;
// Escribe un número incrementado en el archivo.
fs.writeFile ('test.txt', datos);
// Finaliza la respuesta con un buen mensaje.
response.end ('¡Esta página se actualizó' + datos + 'veces!');
});
} más {
// Indica que no se encontró el archivo solicitado.
response.writeHead (404);
// Y finaliza la solicitud sin enviar ningún dato.
respuesta.end ();
}
});
// Escucha en el puerto 8080.
}). escuchar (8080);
Pruébalo ahora; Debería funcionar como se esperaba.
Anuncio
Acceso a bases de datos MySQL
La mayoría de las tecnologías tradicionales del lado del servidor tienen un medio incorporado para conectarse y consultar una base de datos. Con Node.js, debe instalar una biblioteca. Para este tutorial, elegí el nodo estable y fácil de usar mysql . El nombre completo de este módulo es [correo electrónico protegido] (todo después de la @ es el número de versión). Abra su consola, navegue hasta el directorio donde almacenó sus scripts y ejecute el siguiente comando:
npm install [correo electrónico protegido]
Esto descarga e instala el módulo, y también crea la carpeta node_modules en el directorio actual. Ahora veamos cómo podemos usar esto en nuestro código; ver el siguiente ejemplo:
// Incluir módulo http,
var http = require ('http'),
// Y el módulo mysql que acabas de instalar.
mysql = require ("mysql");
// Crea la conexión.
// Los datos son predeterminados para la nueva instalación de mysql y deben cambiarse de acuerdo con su configuración.
conexión var = mysql.createConnection ({
usuario: "root",
contraseña: "",
base de datos: "db_name"
});
// Crea el servidor http.
http.createServer (función (solicitud, respuesta) {
// Adjuntar escucha al evento final.
request.on ('fin', función () {
// Consulta la base de datos.
connection.query ('SELECT * FROM your_table;', function (error, filas, campos) {
response.writeHead (200, {
'Content-Type': 'x-application / json'
});
// Enviar datos como una cadena JSON.
// La variable de filas contiene el resultado de la consulta.
response.end (JSON.stringify (filas));
});
});
// Escucha en el puerto 8080.
}). escuchar (8080);
Consultar la base de datos con esta biblioteca es fácil; simplemente ingrese la cadena de consulta y la función de devolución de llamada. En una aplicación real, debe verificar si hubo errores (el parámetro de error no estará undefined si ocurrieron errores) y enviar códigos de respuesta dependiendo del éxito o el fracaso de la consulta. También tenga en cuenta que hemos establecido Content-Type en x-application/json , que es el tipo MIME válido para JSON. El parámetro rows contiene el resultado de la consulta, y simplemente convertimos los datos en rows a una estructura JSON utilizando el método JSON.stringify() .
Guarde este archivo como mysql.js y ejecútelo (si tiene instalado MySQL):
nodo mysql.js
Navegue a http://localhost:8080 en su navegador, y se le pedirá que descargue el archivo con formato JSON.
Conclusión
Cada función en Node.js es asíncrona.
Node.js requiere trabajo extra, pero la recompensa de una aplicación rápida y robusta lo vale. Si no desea hacer todo en el nivel más bajo, siempre puede elegir un marco, como> Express, para facilitar el desarrollo de aplicaciones.
Node.js es una tecnología prometedora y una excelente opción para una aplicación de alta carga. Ha sido probado por corporaciones, como Microsoft, eBay y Yahoo.
