Nodejs
Nodejs
Nodejs
Node.js - Inicio
Node.js - Introducción
Node.js - Configuración del entorno
Node.js - Primera aplicación
Node.js - Terminal REPL
Node.js - Administrador de paquetes (NPM)
Node.js - Concepto de devoluciones de llamada
Node.js - Bucle de eventos
Node.js - Emisor de eventos
Node.js - Buffers
Node.js - Streams
Node.js - Sistema de archivos
Node.js - Objetos globales
Node.js - Módulos de utilidad
Node.js - Módulo web
Node.js - Express Framework
Node.js - API RESTFul
Node.js - Aplicación de escalado
Node.js - Embalaje
Node.js - Introducción
¿Qué es Node.js?
Node.js es una plataforma del lado del servidor construida en el motor
JavaScript de Google Chrome (motor V8). Node.js fue desarrollado por Ryan
Dahl en 2009 y su última versión es v0.10.36. La definición de Node.js tal
como la proporciona su documentación oficial es la siguiente:
Node.js es una plataforma basada en el tiempo de ejecución de JavaScript de
Chrome para crear fácilmente aplicaciones de red rápidas y escalables. Node.js utiliza un
modelo de E / S sin bloqueo controlado por eventos que lo hace liviano y eficiente,
perfecto para aplicaciones en tiempo real de uso intensivo de datos que se ejecutan en
dispositivos distribuidos.
Conceptos
El siguiente diagrama muestra algunas partes importantes de Node.js que
discutiremos en detalle en los capítulos siguientes.
¿Dónde usar Node.js?
Las siguientes son las áreas donde Node.js se está demostrando como un
socio tecnológico perfecto.
Aplicaciones vinculadas de E / S
Aplicaciones de transmisión de datos
Aplicaciones intensivas de datos en tiempo real (DIRT)
Aplicaciones basadas en API JSON
Aplicaciones de una sola página
Editor de texto
Esto se usará para escribir su programa. Los ejemplos de algunos editores
incluyen el Bloc de notas de Windows, el comando Editar del sistema
operativo, Breve, Epsilon, EMACS y vim o vi.
El nombre y la versión del editor de texto pueden variar en diferentes sistemas
operativos. Por ejemplo, el Bloc de notas se usará en Windows y vim o vi se
pueden usar en Windows, así como en Linux o UNIX.
Los archivos que crea con su editor se denominan archivos fuente y contienen
el código fuente del programa. Los archivos de origen para los programas
Node.js generalmente se nombran con la extensión " .js ".
Antes de comenzar su programación, asegúrese de tener un editor de texto y
tener suficiente experiencia para escribir un programa de computadora,
guardarlo en un archivo y finalmente ejecutarlo.
OS Nombre de archivo
Ventanas nodo-v6.3.1-x64.msi
Linux node-v6.3.1-linux-x86.tar.gz
Mac node-v6.3.1-darwin-x86.tar.gz
SunOS node-v6.3.1-sunos-x86.tar.gz
OS Salida
Instalación en Windows
Use el archivo MSI y siga las instrucciones para instalar Node.js. De manera
predeterminada, el instalador usa la distribución Node.js en C: \ Archivos de
programa \ nodejs. El instalador debe establecer el directorio C: \ Archivos de
programa \ nodejs \ bin en la variable de entorno PATH de la ventana. Reinicie
cualquier solicitud de comando abierto para que el cambio surta efecto.
Iniciando REPL
Expresión simple
Usar variables
Puede hacer uso de variables para almacenar valores e imprimir más tarde
como cualquier script convencional. Si no se usa la palabra clave var , el valor
se almacena en la variable y se imprime. Mientras que si se usa la palabra
clave var , el valor se almacena pero no se imprime. Puede imprimir variables
usando console.log () .
$ node
> x = 10
10
> var y = 10
undefined
> x + y
20
> console.log("Hello World")
Hello World
undefined
Expresión Multilínea
Subrayar variable
Comandos REPL
ctrl + c - termina el comando actual.
ctrl + c dos veces - termina el Nodo REPL.
ctrl + d - termina el Nodo REPL.
Teclas arriba / abajo : vea el historial de comandos y modifique los comandos
anteriores.
Teclas de tabulación : lista de comandos actuales.
.help : lista de todos los comandos.
.break : sale de la expresión multilínea.
.clear : sale de la expresión multilínea.
.save filename : guarda la sesión actual de Node REPL en un archivo.
.load filename : carga el contenido del archivo en la sesión REPL Nodo actual.
Deteniendo REPL
Como se mencionó anteriormente, deberá usar ctrl-c dos veces para salir de
Node.js REPL.
$ node
>
(^C again to quit)
>
Node.js - NPM
Node Package Manager (NPM) proporciona dos funcionalidades principales:
Repositorios en línea para paquetes / módulos node.js que se pueden buscar
en search.nodejs.org
Utilidad de línea de comandos para instalar paquetes Node.js, hacer gestión de
versiones y gestión de dependencias de paquetes Node.js.
NPM viene incluido con los instalables de Node.js después de la versión
v0.6.3. Para verificar lo mismo, abra la consola y escriba el siguiente comando
y vea el resultado:
$ npm --version
2.7.1
Si está ejecutando una versión anterior de NPM, es bastante fácil actualizarla
a la última versión. Simplemente use el siguiente comando desde la raíz:
$ sudo npm install npm -g
/usr/bin/npm -> /usr/lib/node_modules/npm/bin/npm-cli.js
npm@2.7.1 /usr/lib/node_modules/npm
Usando package.json
package.json está presente en el directorio raíz de cualquier aplicación /
módulo Node y se usa para definir las propiedades de un paquete. Abramos
package.json del paquete express presente en node_modules / express /
{
"name": "express",
"description": "Fast, unopinionated, minimalist web
framework",
"version": "4.11.2",
"author": {
"contributors": [{
"name": "Aaron Heckmann",
"email": "aaron.heckmann+github@gmail.com"
},
{
"name": "Ciaran Jessup",
"email": "ciaranj@gmail.com"
},
{
"name": "Douglas Christopher Wilson",
"email": "doug@somethingdoug.com"
},
{
"name": "Guillermo Rauch",
"email": "rauchg@gmail.com"
},
{
"name": "Jonathan Ong",
"email": "me@jongleberry.com"
},
{
"name": "Roman Shtylman",
"email": "shtylman+expressjs@gmail.com"
},
{
"name": "Young Jae Sim",
"email": "hanul@hanul.me"
} ],
"dependencies": {
"accepts": "~1.2.3",
"content-disposition": "0.5.0",
"cookie-signature": "1.0.5",
"debug": "~2.1.1",
"depd": "~1.0.0",
"escape-html": "1.0.1",
"etag": "~1.5.1",
"finalhandler": "0.3.3",
"fresh": "0.2.4",
"media-typer": "0.3.0",
"methods": "~1.1.1",
"on-finished": "~2.2.0",
"parseurl": "~1.3.0",
"path-to-regexp": "0.1.3",
"proxy-addr": "~1.0.6",
"qs": "2.3.3",
"range-parser": "~1.0.2",
"send": "0.11.1",
"serve-static": "~1.8.1",
"type-is": "~1.5.6",
"vary": "~1.0.0",
"cookie": "0.1.2",
"merge-descriptors": "0.0.2",
"utils-merge": "1.0.0"
},
"devDependencies": {
"after": "0.8.1",
"ejs": "2.1.4",
"istanbul": "0.3.5",
"marked": "0.3.3",
"mocha": "~2.1.0",
"should": "~4.6.2",
"supertest": "~0.15.0",
"hjs": "~0.0.6",
"body-parser": "~1.11.0",
"connect-redis": "~2.2.0",
"cookie-parser": "~1.3.3",
"express-session": "~1.10.2",
"jade": "~1.9.1",
"method-override": "~2.3.1",
"morgan": "~1.5.1",
"multiparty": "~4.1.1",
"vhost": "~3.0.0"
},
"engines": {
"node": ">= 0.10.0"
},
"files": [
"LICENSE",
"History.md",
"Readme.md",
"index.js",
"lib/"
],
"scripts": {
"test": "mocha --require test/support/env
--reporter spec --bail --check-leaks test/
test/acceptance/",
"test-cov": "istanbul cover
node_modules/mocha/bin/_mocha
-- --require test/support/env --reporter dot --
check-leaks test/ test/acceptance/",
"test-tap": "mocha --require test/support/env
--reporter tap --check-leaks test/
test/acceptance/",
"test-travis": "istanbul cover
node_modules/mocha/bin/_mocha
--report lcovonly -- --require test/support/env
--reporter spec --check-leaks test/
test/acceptance/"
},
"gitHead": "63ab25579bda70b4927a179b580a9c580b6c7ada",
"bugs": {
"url": "https://github.com/strongloop/express/issues"
},
"_id": "express@4.11.2",
"_shasum": "8df3d5a9ac848585f00a0777601823faecd3b148",
"_from": "express@*",
"_npmVersion": "1.4.28",
"_npmUser": {
"name": "dougwilson",
"email": "doug@somethingdoug.com"
},
"maintainers": [{
"name": "tjholowaychuk",
"email": "tj@vision-media.ca"
},
{
"name": "jongleberry",
"email": "jonathanrichardong@gmail.com"
},
{
"name": "shtylman",
"email": "shtylman@gmail.com"
},
{
"name": "dougwilson",
"email": "doug@somethingdoug.com"
},
{
"name": "aredridel",
"email": "aredridel@nbtsc.org"
},
{
"name": "strongloop",
"email": "callback@strongloop.com"
},
{
"name": "rfeng",
"email": "enjoyjava@gmail.com"
}],
"dist": {
"shasum": "8df3d5a9ac848585f00a0777601823faecd3b148",
"tarball": "https://registry.npmjs.org/express/-
/express-4.11.2.tgz"
},
"directories": {},
"_resolved": "https://registry.npmjs.org/express/-
/express-4.11.2.tgz",
"readme": "ERROR: No README data found!"
}
Atributos de Package.json
nombre - nombre del paquete
version - versión del paquete
description - descripción del paquete
página de inicio - página de inicio del paquete
autor - autor del paquete
contribuyentes - nombre de los contribuyentes al paquete
dependencias : lista de dependencias. NPM instala automáticamente todas las
dependencias mencionadas aquí en la carpeta node_module del paquete.
repositorio - tipo de repositorio y URL del paquete
main - punto de entrada del paquete
palabras clave - palabras clave
Desinstalar un módulo
Use el siguiente comando para desinstalar un módulo Node.js.
$ npm uninstall express
Una vez que NPM desinstala el paquete, puede verificarlo mirando el
contenido del directorio / node_modules / o escriba el siguiente comando:
$ npm ls
Actualización de un módulo
Actualice package.json y cambie la versión de la dependencia que se
actualizará y ejecute el siguiente comando.
$ npm update express
Buscar un módulo
Busque el nombre de un paquete usando NPM.
$ npm search express
Crear un módulo
La creación de un módulo requiere que se genere package.json. Generemos
package.json usando NPM, lo que generará el esqueleto básico de
package.json.
$ npm init
This utility will walk you through creating a package.json
file.
It only covers the most common items, and tries to guess sane
defaults.
console.log(data.toString());
console.log("Program Ended");
Ahora ejecute main.js para ver el resultado:
$ node main.js
Verifique la salida.
Postparaprogramadores is giving self learning content
to teach the world in simple and easy way!!!!!
Program Ended
console.log("Program Ended");
Ahora ejecute main.js para ver el resultado:
$ node main.js
Verifique la salida.
Program Ended
Postparaprogramadores is giving self learning content
to teach the world in simple and easy way!!!!!
Estos dos ejemplos explican el concepto de llamadas bloqueadas y no
bloqueantes.
El primer ejemplo muestra que el programa se bloquea hasta que lee el archivo y
luego solo se procede a finalizar el programa.
El segundo ejemplo muestra que el programa no espera la lectura del archivo y
procede a imprimir "Programa finalizado" y, al mismo tiempo, el programa sin
bloqueo continúa leyendo el archivo.
Por lo tanto, un programa de bloqueo se ejecuta mucho en secuencia. Desde
el punto de vista de la programación, es más fácil implementar la lógica, pero
los programas sin bloqueo no se ejecutan en secuencia. En caso de que un
programa necesite usar cualquier dato para ser procesado, debe mantenerse
dentro del mismo bloque para que sea una ejecución secuencial.
console.log("Program Ended.");
Clase EventEmitter
Como hemos visto en la sección anterior, la clase EventEmitter se encuentra
en el módulo de eventos. Se puede acceder a través del siguiente código:
// Import events module
var events = require('events');
Métodos
No Método y descripción
Señor.
1
addListener (evento, oyente)
Agrega un oyente al final de la matriz de oyentes para el evento especificado. No
se realizan verificaciones para ver si el oyente ya se ha agregado. Las llamadas
múltiples que pasan la misma combinación de evento y escucha harán que el
escucha se agregue varias veces. Devuelve el emisor, por lo que las llamadas se
pueden encadenar.
2
encendido (evento, oyente)
Agrega un oyente al final de la matriz de oyentes para el evento especificado. No
se realizan verificaciones para ver si el oyente ya se ha agregado. Las llamadas
múltiples que pasan la misma combinación de evento y escucha harán que el
escucha se agregue varias veces. Devuelve el emisor, por lo que las llamadas se
pueden encadenar.
3
una vez (evento, oyente)
Agrega un oyente único al evento. Este oyente se invoca solo la próxima vez que
se dispara el evento, después de lo cual se elimina. Devuelve el emisor, por lo que
las llamadas se pueden encadenar.
44
removeListener (evento, oyente)
Elimina un oyente de la matriz de oyentes para el evento
especificado. Precaución: cambia los índices de la matriz en la matriz del oyente
detrás del oyente. removeListener eliminará, como máximo, una instancia de un
oyente de la matriz de oyentes. Si se ha agregado varias veces un único oyente a
la matriz de oyentes para el evento especificado, se debe llamar a removeListener
varias veces para eliminar cada instancia. Devuelve el emisor, por lo que las
llamadas se pueden encadenar.
55
removeAllListeners ([evento])
Elimina todos los oyentes, o los del evento especificado. No es una buena idea
eliminar los oyentes que se agregaron en otra parte del código, especialmente
cuando está en un emisor que no creó (por ejemplo, sockets o secuencias de
archivos). Devuelve el emisor, por lo que las llamadas se pueden encadenar.
66
setMaxListeners (n)
Por defecto, EventEmitters imprimirá una advertencia si se agregan más de 10
oyentes para un evento en particular. Este es un valor predeterminado útil que
ayuda a encontrar pérdidas de memoria. Obviamente, no todos los Emisores
deberían limitarse a 10. Esta función permite que se incremente. Establecer en
cero para ilimitado.
77
oyentes (evento)
Devuelve una matriz de oyentes para el evento especificado.
8
emitir (evento, [arg1], [arg2], [...])
Ejecute cada uno de los oyentes en orden con los argumentos
proporcionados. Devuelve verdadero si el evento tuvo oyentes, falso de lo
contrario.
Métodos de clase
No Método y descripción
Señor.
1
listenerCount (emisor, evento)
Devuelve el número de oyentes para un evento determinado.
Eventos
No Eventos y descripción
Señor.
1
newListener
evento - Cadena: el nombre del evento
oyente - Función: la función de controlador de eventos
Este evento se emite cada vez que se agrega un oyente. Cuando se desencadena
este evento, es posible que el oyente aún no se haya agregado a la matriz de
oyentes para el evento.
2
removeListener
event - String El nombre del evento
oyente - Función La función de controlador de eventos
Este evento se emite cada vez que alguien elimina a un oyente. Cuando se
desencadena este evento, es posible que el oyente aún no se haya eliminado de
la matriz de oyentes para el evento.
Ejemplo
Cree un archivo js llamado main.js con el siguiente código Node.js:
Demo en vivo
var events = require('events');
var eventEmitter = new events.EventEmitter();
// listener #1
var listner1 = function listner1() {
console.log('listner1 executed.');
}
// listener #2
var listner2 = function listner2() {
console.log('listner2 executed.');
}
var eventListeners =
require('events').EventEmitter.listenerCount
(eventEmitter,'connection');
console.log(eventListeners + " Listner(s) listening to
connection event");
eventListeners =
require('events').EventEmitter.listenerCount(eventEmitter,'co
nnection');
console.log(eventListeners + " Listner(s) listening to
connection event");
console.log("Program Ended.");
Creando Buffers
Node Buffer se puede construir de varias maneras.
Método 1
Método 2
Método 3
Escribiendo a Buffers
Sintaxis
Parámetros
Aquí está la descripción de los parámetros utilizados:
string : estos son los datos de cadena que se escribirán en el búfer.
offset : este es el índice del búfer en el que comenzar a escribir. El valor
predeterminado es 0.
longitud : este es el número de bytes a escribir. Por defecto es buffer.length.
codificación : codificación para usar. 'utf8' es la codificación predeterminada.
Valor de retorno
Ejemplo
Demo en vivo
buf = new Buffer(256);
len = buf.write("Simply Easy Learning");
Leyendo de Buffers
Sintaxis
Parámetros
Valor de retorno
Ejemplo
Demo en vivo
buf = new Buffer(26);
for (var i = 0 ; i < 26 ; i++) {
buf[i] = i + 97;
}
Valor de retorno
Ejemplo
Demo en vivo
var buf = new Buffer('Simply Easy Learning');
var json = buf.toJSON(buf);
console.log(json);
Tampones Concatenados
Sintaxis
Parámetros
Valor de retorno
Ejemplo
Demo en vivo
var buffer1 = new Buffer('Postparaprogramadores ');
var buffer2 = new Buffer('Simply Easy Learning');
var buffer3 = Buffer.concat([buffer1,buffer2]);
Comparar tampones
Sintaxis
Parámetros
Valor de retorno
Ejemplo
Demo en vivo
var buffer1 = new Buffer('ABC');
var buffer2 = new Buffer('ABCD');
var result = buffer1.compare(buffer2);
if(result < 0) {
console.log(buffer1 +" comes before " + buffer2);
} else if(result === 0) {
console.log(buffer1 +" is same as " + buffer2);
} else {
console.log(buffer1 +" comes after " + buffer2);
}
Copia de búfer
Sintaxis
Parámetros
Valor de retorno
Sin valor de retorno. Copia datos de una región de este búfer a una región en
el búfer de destino, incluso si la región de memoria de destino se superpone
con la fuente. Si no está definido, los parámetros targetStart y sourceStart
tienen un valor predeterminado de 0, mientras que sourceEnd tiene el valor
predeterminado de buffer.length.
Ejemplo
Demo en vivo
var buffer1 = new Buffer('ABC');
//copy a buffer
var buffer2 = new Buffer(3);
buffer1.copy(buffer2);
console.log("buffer2 content: " + buffer2.toString());
Tampón de rebanada
Sintaxis
Parámetros
Valor de retorno
Ejemplo
Demo en vivo
var buffer1 = new Buffer('Postparaprogramadores');
//slicing a buffer
var buffer2 = buffer1.slice(0,9);
console.log("buffer2 content: " + buffer2.toString());
Cuando se ejecuta el programa anterior, produce el siguiente resultado:
buffer2 content: Tutorials
Valor de retorno
Ejemplo
Demo en vivo
var buffer = new Buffer('Postparaprogramadores');
Referencia de métodos
A continuación se incluye una referencia del módulo Buffers disponible en
Node.js. Para más detalles, puede consultar la documentación oficial.
Métodos de clase
No Método y descripción
Señor.
1
Buffer.isEncoding (codificación)
Devuelve verdadero si la codificación es un argumento de codificación válido, falso
en caso contrario.
2
Buffer.isBuffer (obj)
Comprueba si obj es un Buffer.
3
Buffer.byteLength (cadena [, codificación])
Da la longitud de bytes real de una cadena. la codificación por defecto es 'utf8'. No
es lo mismo que String.prototype.length, ya que String.prototype.length devuelve
el número de caracteres en una cadena.
44
Buffer.concat (list [, totalLength])
Devuelve un búfer que es el resultado de concatenar todos los búferes de la lista
juntos.
55
Buffer.compare (buf1, buf2)
Lo mismo que buf1.compare (buf2). Útil para ordenar una variedad de buffers.
Node.js - Streams
¿Qué son las corrientes?
Las secuencias son objetos que le permiten leer datos de una fuente o escribir
datos en un destino de manera continua. En Node.js, hay cuatro tipos de
transmisiones:
Legible : secuencia que se utiliza para la operación de lectura.
Writable : secuencia que se utiliza para la operación de escritura.
Dúplex : flujo que se puede utilizar para operaciones de lectura y escritura.
Transformar : un tipo de flujo dúplex donde la salida se calcula en función de la
entrada.
Cada tipo de Stream es una instancia de EventEmitter y lanza varios eventos
en diferentes instancias de tiempos. Por ejemplo, algunos de los eventos más
utilizados son:
datos : este evento se activa cuando hay datos disponibles para leer.
end : este evento se activa cuando no hay más datos para leer.
error : este evento se activa cuando hay algún error al recibir o escribir datos.
terminar : este evento se activa cuando todos los datos se han vaciado al sistema
subyacente.
Este tutorial proporciona una comprensión básica de las operaciones
comúnmente utilizadas en Streams.
Leer desde una corriente
Cree un archivo de texto llamado input.txt que tenga el siguiente contenido:
Postparaprogramadores is giving self learning content
to teach the world in simple and easy way!!!!!
Cree un archivo js llamado main.js con el siguiente código:
var fs = require("fs");
var data = '';
readerStream.on('end',function() {
console.log(data);
});
readerStream.on('error', function(err) {
console.log(err.stack);
});
console.log("Program Ended");
Ahora ejecute main.js para ver el resultado:
$ node main.js
Verifique la salida.
Program Ended
Postparaprogramadores is giving self learning content
to teach the world in simple and easy way!!!!!
writerStream.on('error', function(err) {
console.log(err.stack);
});
console.log("Program Ended");
Ahora ejecute main.js para ver el resultado:
$ node main.js
Verifique la salida.
Program Ended
Write completed.
Ahora abra output.txt creado en su directorio actual; debe contener lo
siguiente:
Simply Easy Learning
console.log("Program Ended");
Ahora ejecute main.js para ver el resultado:
$ node main.js
Verifique la salida.
Program Ended
Abra output.txt creado en su directorio actual; debe contener lo siguiente:
Postparaprogramadores is giving self learning content
to teach the world in simple and easy way!!!!!
console.log("File Compressed.");
console.log("File Decompressed.");
Ahora ejecute main.js para ver el resultado:
$ node main.js
Verifique la salida.
File Decompressed.
Node.js - Sistema de archivos
Node implementa File I / O usando envoltorios simples alrededor de funciones
POSIX estándar. El módulo Sistema de archivos de nodo (fs) se puede
importar utilizando la siguiente sintaxis:
var fs = require("fs")
Sincrónico vs Asincrónico
Cada método en el módulo fs tiene formas síncronas y asíncronas. Los
métodos asincrónicos toman el último parámetro como la devolución de
llamada de la función de finalización y el primer parámetro de la función de
devolución de llamada como error. Es mejor usar un método asincrónico en
lugar de un método sincrónico, ya que el primero nunca bloquea un programa
durante su ejecución, mientras que el segundo sí.
Ejemplo
// Asynchronous read
fs.readFile('input.txt', function (err, data) {
if (err) {
return console.error(err);
}
console.log("Asynchronous read: " + data.toString());
});
// Synchronous read
var data = fs.readFileSync('input.txt');
console.log("Synchronous read: " + data.toString());
console.log("Program Ended");
Program Ended
Asynchronous read: Postparaprogramadores is giving self
learning content
to teach the world in simple and easy way!!!!!
Las siguientes secciones de este capítulo proporcionan un conjunto de buenos
ejemplos sobre los principales métodos de E / S de archivos.
Abrir un archivo
Sintaxis
Parámetros
Banderas
Las banderas para las operaciones de lectura / escritura son:
No Bandera y descripción
Señor.
1
r
Abrir archivo para leer. Se produce una excepción si el archivo no existe.
2
r+
Abrir archivo para leer y escribir. Se produce una excepción si el archivo no
existe.
3
rs
Abrir archivo para leer en modo síncrono.
44
rs +
Abra el archivo para leer y escribir, pidiéndole al sistema operativo que lo abra
sincrónicamente. Consulte las notas para 'rs' sobre el uso de esto con precaución.
55
w
Abrir archivo para escribir. El archivo se crea (si no existe) o se trunca (si existe).
66
wx
Como 'w' pero falla si la ruta existe.
77
w+
Abrir archivo para leer y escribir. El archivo se crea (si no existe) o se trunca (si
existe).
8
wx +
Como 'w +' pero falla si la ruta existe.
99
un
Abrir archivo para anexar. El archivo se crea si no existe.
10
hacha
Como 'a' pero falla si la ruta existe.
11
a+
Abrir archivo para leer y agregar. El archivo se crea si no existe.
12
hacha +
Como 'a +' pero falla si la ruta existe.
Ejemplo
Parámetros
No Método y descripción
Señor.
1
stats.isFile ()
Devuelve verdadero si el tipo de archivo de un archivo simple.
2
stats.isDirectory ()
Devuelve verdadero si el tipo de archivo de un directorio.
3
stats.isBlockDevice ()
Devuelve verdadero si el tipo de archivo de un dispositivo de bloque.
44
stats.isCharacterDevice ()
Devuelve verdadero si el tipo de archivo de un dispositivo de caracteres.
55
stats.isSymbolicLink ()
Devuelve verdadero si el tipo de archivo de un enlace simbólico.
66
stats.isFIFO ()
Devuelve verdadero si el tipo de archivo de un FIFO.
77
stats.isSocket ()
Devuelve verdadero si el tipo de archivo de un asocket.
Ejemplo
Escribir un archivo
Sintaxis
Parámetros
Ejemplo
Leer un archivo
Sintaxis
Parámetros
Ejemplo
Cerrar un archivo
Sintaxis
Parámetros
Ejemplo
Vamos a crear un archivo js llamado main.js que tenga el siguiente código:
var fs = require("fs");
var buf = new Buffer(1024);
Truncar un archivo
Sintaxis
Parámetros
Ejemplo
Eliminar un archivo
Sintaxis
Parámetros
Ejemplo
Crear un directorio
Sintaxis
Parámetros
Ejemplo
Leer un directorio
Sintaxis
Ejemplo
Eliminar un directorio
Sintaxis
Parámetros
Ejemplo
fs.readdir("/tmp/",function(err, files) {
if (err) {
return console.error(err);
}
files.forEach( function (file) {
console.log( file );
});
});
});
Referencia de métodos
A continuación se incluye una referencia del módulo del sistema de archivos disponible
en Node.js. Para más detalles puede consultar la documentación oficial.
Node.js - Objetos globales
Los objetos globales de Node.js son de naturaleza global y están disponibles
en todos los módulos. No necesitamos incluir estos objetos en nuestra
aplicación, sino que podemos usarlos directamente. Estos objetos son
módulos, funciones, cadenas y el propio objeto como se explica a
continuación.
Ejemplo
console.log( __filename );
__dirname
El __dirname representa el nombre del directorio en el que reside el script que
se está ejecutando actualmente.
Ejemplo
console.log( __dirname );
Ahora ejecute main.js para ver el resultado:
$ node main.js
Según la ubicación de su programa, imprimirá el nombre del directorio actual
de la siguiente manera:
/web/com/1427091028_21099
Ejemplo
clearTimeout (t)
La función global clearTimeout (t) se usa para detener un temporizador que
se creó previamente con setTimeout (). Aquí t es el temporizador devuelto por
la función setTimeout ().
Ejemplo
Ejemplo
Objetos globales
La siguiente tabla proporciona una lista de otros objetos que usamos con
frecuencia en nuestras aplicaciones. Para más detalles, puede consultar la
documentación oficial.
1 Consola
2 Proceso
Se utiliza para obtener información sobre el proceso actual. Proporciona múltiples
eventos relacionados con actividades de proceso.
1 Módulo OS
2 Módulo de ruta
Proporciona utilidades para manejar y transformar rutas de archivos.
3 Módulo de red
Proporciona servidores y clientes como flujos. Actúa como un contenedor de red.
44 Módulo DNS
Proporciona funciones para realizar búsquedas DNS reales, así como para utilizar
funcionalidades subyacentes de resolución de nombres del sistema operativo.
55 Módulo de dominio
Proporciona formas de manejar múltiples operaciones de E / S diferentes como
un solo grupo.
// Create a server
http.createServer( function (request, response) {
// Parse the request containing file name
var pathname = url.parse(request.url).pathname;
<body>
Hello World!
</body>
</html>
response.on('end', function() {
// Data received completely.
console.log(body);
});
}
// Make a request to the server
var req = http.request(options, callback);
req.end();
<body>
Hello World!
</body>
</html>
Verifique la salida al final del servidor.
Server running at http://127.0.0.1:8081/
Request for /index.htm received.
Node.js - Express Framework
Resumen expreso
Express es un marco de aplicación web Node.js mínimo y flexible que
proporciona un conjunto robusto de características para desarrollar
aplicaciones web y móviles. Facilita el rápido desarrollo de aplicaciones web
basadas en nodos. Las siguientes son algunas de las características
principales de Express Framework:
Permite configurar middlewares para responder a solicitudes HTTP.
Define una tabla de enrutamiento que se utiliza para realizar diferentes acciones
según el método HTTP y la URL.
Permite renderizar dinámicamente páginas HTML basadas en pasar argumentos a
plantillas.
Instalando Express
Primero, instale el framework Express globalmente usando NPM para que
pueda usarse para crear una aplicación web usando un terminal de nodo.
$ npm install express --save
El comando anterior guarda la instalación localmente en
el directorio node_modules y crea un directorio express dentro de
node_modules. Debe instalar los siguientes módulos importantes junto con
express:
body-parser : este es un middleware de node.js para manejar datos de formulario
codificados JSON, Raw, Text y URL.
cookie-parser : analiza el encabezado de Cookie y rellena req.cookies con un
objeto marcado por los nombres de las cookies.
multer : este es un middleware de node.js para manejar datos multiparte /
formulario.
$ npm install body-parser --save
$ npm install cookie-parser --save
$ npm install multer --save
Enrutamiento Básico
Hemos visto una aplicación básica que atiende solicitudes HTTP para la
página de inicio. El enrutamiento se refiere a determinar cómo una aplicación
responde a una solicitud del cliente a un punto final particular, que es un URI
(o ruta) y un método de solicitud HTTP específico (GET, POST, etc.).
Extendiremos nuestro programa Hello World para manejar más tipos de
solicitudes HTTP.
var express = require('express');
var app = express();
app.use(express.static('public'));
OBTENER Método
Aquí hay un ejemplo simple que pasa dos valores usando el método HTML
FORM GET. Vamos a usar el router process_get dentro de server.js para
manejar esta entrada.
<html>
<body>
</body>
</html>
Guardemos el código anterior en index.htm y modifique server.js para manejar
las solicitudes de la página de inicio, así como la entrada enviada por el
formulario HTML.
var express = require('express');
var app = express();
app.use(express.static('public'));
app.get('/index.htm', function (req, res) {
res.sendFile( __dirname + "/" + "index.htm" );
})
First Name:
Last Name:
Método POST
Aquí hay un ejemplo simple que pasa dos valores usando el método HTML
FORM POST. Vamos a usar el router process_get dentro de server.js para
manejar esta entrada.
<html>
<body>
<form action = "http://127.0.0.1:8081/process_post"
method = "POST">
First Name: <input type = "text" name =
"first_name"> <br>
Last Name: <input type = "text" name = "last_name">
<input type = "submit" value = "Submit">
</form>
</body>
</html>
app.use(express.static('public'));
app.get('/index.htm', function (req, res) {
res.sendFile( __dirname + "/" + "index.htm" );
})
First Name:
Last Name:
Ahora puede ingresar el nombre y apellido y luego hacer clic en el botón
enviar para ver el siguiente resultado:
{"first_name":"John","last_name":"Paul"}
Subir archivo
El siguiente código HTML crea un formulario de carga de archivos. Este
formulario tiene el atributo de método establecido en POST y el atributo
enctype está configurado en multipart / form-data
<html>
<head>
<title>File Uploading Form</title>
</head>
<body>
<h3>File Upload:</h3>
Select a file to upload: <br />
</body>
</html>
Guardemos el código anterior en index.htm y modifique server.js para manejar
las solicitudes de la página de inicio, así como la carga de archivos.
var express = require('express');
var app = express();
var fs = require("fs");
app.use(express.static('public'));
app.use(bodyParser.urlencoded({ extended: false }));
app.use(multer({ dest: '/tmp/'}));
console.log( response );
res.end( JSON.stringify( response ) );
});
});
})
NOTE: This is just dummy form and would not work, but it must
work at your server.
Manejo de cookies
Puede enviar cookies a un servidor Node.js que puede manejar lo mismo
utilizando la siguiente opción de middleware. El siguiente es un ejemplo simple
para imprimir todas las cookies enviadas por el cliente.
var express = require('express')
var cookieParser = require('cookie-parser')
Métodos HTTP
Los siguientes cuatro métodos HTTP se usan comúnmente en la arquitectura
basada en REST.
GET : se utiliza para proporcionar un acceso de solo lectura a un recurso.
PUT : se usa para crear un nuevo recurso.
BORRAR : se utiliza para eliminar un recurso.
POST : se utiliza para actualizar un recurso existente o crear un nuevo recurso.
"user2" : {
"name" : "suresh",
"password" : "password2",
"profession" : "librarian",
"id": 2
},
"user3" : {
"name" : "ramesh",
"password" : "password3",
"profession" : "clerk",
"id": 3
}
}
En base a esta información, proporcionaremos las siguientes API RESTful.
"user2" : {
"name" : "suresh",
"password" : "password2",
"profession" : "librarian",
"id": 2
},
"user3" : {
"name" : "ramesh",
"password" : "password3",
"profession" : "clerk",
"id": 3
}
}
Agregar usuario
La siguiente API le mostrará cómo agregar un nuevo usuario a la lista. A
continuación se detallan los nuevos usuarios:
user = {
"user4" : {
"name" : "mohit",
"password" : "password4",
"profession" : "teacher",
"id": 4
}
}
Puede aceptar la misma entrada en forma de JSON utilizando la llamada Ajax,
pero para enseñar el punto de vista, aquí lo estamos codificando. A
continuación se muestra la API addUser a un nuevo usuario en la base de
datos:
server.js
var express = require('express');
var app = express();
var fs = require("fs");
var user = {
"user4" : {
"name" : "mohit",
"password" : "password4",
"profession" : "teacher",
"id": 4
}
}
"user1":{"name":"mahesh","password":"password1","profession":
"teacher","id":1},
"user2":{"name":"suresh","password":"password2","profession":
"librarian","id":2},
"user3":{"name":"ramesh","password":"password3","profession":
"clerk","id":3},
"user4":{"name":"mohit","password":"password4","profession":"
teacher","id":4}
}
Mostrar detalle
Ahora implementaremos una API que se llamará utilizando la ID de usuario y
mostrará los detalles del usuario correspondiente.
server.js
var express = require('express');
var app = express();
var fs = require("fs");
var id = 2;
console.log( data );
res.end( JSON.stringify(data));
});
})
El método exec ()
El método child_process.exec ejecuta un comando en un shell y almacena el
resultado. Tiene la siguiente firma:
child_process.exec(command[, options], callback)
Parámetros
Ejemplo
Vamos a crear dos archivos js llamados support.js y master.js -
Archivo: support.js
console.log("Child Process " + process.argv[2] + " executed."
);
Archivo: master.js
const fs = require('fs');
const child_process = require('child_process');
if (error) {
console.log(error.stack);
console.log('Error code: '+error.code);
console.log('Signal received: '+error.signal);
}
console.log('stdout: ' + stdout);
console.log('stderr: ' + stderr);
});
stderr:
Child process exited with exit code 0
stdout: Child Process 0 executed.
stderr:
Child process exited with exit code 0
stdout: Child Process 2 executed.
El método spawn ()
El método child_process.spawn inicia un nuevo proceso con un comando
dado. Tiene la siguiente firma:
child_process.spawn(command[, args][, options])
Parámetros
El método spawn () devuelve streams (stdout & stderr) y debe usarse cuando
el proceso devuelve una cantidad de datos en volumen. spawn () comienza a
recibir la respuesta tan pronto como el proceso comienza a ejecutarse.
Ejemplo
Cree dos archivos js llamados support.js y master.js:
Archivo: support.js
console.log("Child Process " + process.argv[2] + " executed."
);
Archivo: master.js
const fs = require('fs');
const child_process = require('child_process');
El método fork ()
El método child_process.fork es un caso especial de spawn () para crear
procesos Node. Tiene la siguiente firma:
child_process.fork(modulePath[, args][, options])
Parámetros
Ejemplo
Cree dos archivos js llamados support.js y master.js:
Archivo: support.js
console.log("Child Process " + process.argv[2] + " executed."
);
Archivo: master.js
const fs = require('fs');
const child_process = require('child_process');
Instalación JXcore
Instalar JXcore es bastante simple. Aquí hemos proporcionado instrucciones
paso a paso sobre cómo instalar JXcore en su sistema. Siga los pasos que se
detallan a continuación:
Paso 1
Paso 2
Descomprima el archivo descargado jx_rh64.zip y copie el binario jx en / usr /
bin o puede estar en cualquier otro directorio basado en la configuración de su
sistema.
$ unzip jx_rh64.zip
$ cp jx_rh64/jx /usr/bin
Paso 3
Etapa 4
Empaquetando el Código
Considere que tiene un proyecto con los siguientes directorios donde guardó
todos sus archivos, incluidos Node.js, archivo principal, index.js y todos los
módulos instalados localmente.
drwxr-xr-x 2 root root 4096 Nov 13 12:42 images
-rwxr-xr-x 1 root root 30457 Mar 6 12:19 index.htm
-rwxr-xr-x 1 root root 30452 Mar 1 12:54 index.js
drwxr-xr-x 23 root root 4096 Jan 15 03:48 node_modules
drwxr-xr-x 2 root root 4096 Mar 21 06:10 scripts
drwxr-xr-x 2 root root 4096 Feb 15 11:56 style
Para empaquetar el proyecto anterior, simplemente necesita ir dentro de este
directorio y emitir el siguiente comando jx. Suponiendo que index.js es el
archivo de entrada para su proyecto Node.js:
$ jx package index.js index
Aquí podría haber usado cualquier otro nombre de paquete en lugar
de índice. Hemos utilizado index porque queríamos mantener nuestro nombre
de archivo principal como index.jx. Sin embargo, el comando anterior
empacará todo y creará los siguientes dos archivos:
index.jxp Este es un archivo intermedio que contiene los detalles completos del
proyecto necesarios para compilar el proyecto.
index.jx Este es el archivo binario que tiene el paquete completo que está listo
para ser enviado a su cliente o su entorno de producción.
Lanzamiento de archivo JX
Considere que su proyecto original de Node.js se ejecutaba de la siguiente
manera:
$ node index.js command_line_arguments
Después de compilar su paquete usando JXcore, se puede iniciar de la
siguiente manera:
$ jx index.jx command_line_arguments
Para saber más sobre JXcore, puede consultar su sitio web oficial.