Dirigir proyectos de tecnologías de información (T.I.) para contribuir a la productividad y logro de los objetivos estratégicos de las organizaciones utilizando las metodologías apropiadas.
El alumno desarrollará aplicaciones Web empleando herramientas tecnologías, para el desarrollo de aplicaciones Web a través del uso de las diferentes tecnologías.
Ceballos, Francisco Javier. (2007) Java 2 Interfaces gráficas y aplicaciones para internet (2da. Edición) México, D.F. México AlfaOmega Ra- Ma
Puentes Cairo, Juan Francisco. (2009) Principios de seguridad en el comercio electrónico (1era Edición) México, D.F. México AlfaOmega Ra- Ma
Vora, P. (2009) Web Applications Design Patters ( Interactive Technologies. 1st Ed.) New, Jersey. EE.UU. Morgan Kaufmann.
Mcneil, Patrick (2008 ) The web designer’s Idea Book: The Ultimate Guide Ontario Cánada FW Publications Inc.
Da clic aquí para conocer acerca de UML-based WEB Enginnering.
Da clic en la imagen o aquí para descargar el documento pdf con la información sobre seguridad web.
Para ello se debe realizar y verificar el cumplimiento de:
Una tarea común para un servidor web puede ser abrir un archivo en el servidor y devolver el contenido al cliente.
Paso1. Crea el siguiente archivo llamado demo1.html:
< html > < body > < h1 >My Header< /h1 > < p >My paragraph.< /p > < /body > < /html >
Paso2. Crea un archivo node.js que lea el archivo HTML y devuelva el contenido:
var http = require('http');
var fs = require('fs');
http.createServer(function (req, res) {
fs.readFile('demo1.html', function(err, data) {
res.writeHead(200, {'Content-Type': 'text/html'});
res.write(data);
return res.end();
});
}).listen(8080);
Paso3. Guarda el archivo anterior con el nombre leerarchivos.js e inicia el archivo con el comando node leerarchivos.js
CREAR ARCHIVOS - fs.appendFile()El fs.appendFile()método agrega contenido especificado a un archivo. Si el archivo no existe, se creará el archivo:
Crea un nuevo archivo usando el método appendFile():
var fs = require('fs');
fs.appendFile('nuevoarchivo.txt', 'Hello content!', function (err) {
if (err) throw err;
console.log('Saved!');
});
CREA ARCHIVOS - fs.open()
Crea un nuevo archivo vacío con el método open():
var fs = require('fs');
fs.open('nuevoarchivo2.txt', 'w', function (err, file) {
if (err) throw err;
console.log('Saved!');
});
CREA ARCHIVOS - fs.writeFile()
Crea un nuevo archivo usando el método writeFile():
var fs = require('fs');
fs.writeFile('mynewfile3.txt', 'Hello content!', function (err) {
if (err) throw err;
console.log('Saved!');
});
ACTUALIZA ARCHIVOS - fs.appendFile()
El método fs.appendFile() agrega el contenido especificado al final del archivo especificado:
var fs = require('fs');
fs.appendFile('mynewfile1.txt', ' This is my text.', function (err) {
if (err) throw err;
console.log('Updated!');
});
ACTUALIZAR ARCHIVOS - fs.writeFile()
El fs.writeFile() reemplaza el archivo y contenido especifico:
var fs = require('fs');
fs.writeFile('mynewfile3.txt', 'This is my text', function (err) {
if (err) throw err;
console.log('Replaced!');
});
BORRAR ARCHIVOS - fs.unlink()
El fs.unlink() elimina el archivo especificado:
var fs = require('fs');
fs.unlink('mynewfile2.txt', function (err) {
if (err) throw err;
console.log('File deleted!');
});
RENOMBRAR ARCHIVOS - fs.rename()
El fs.rename() cambia el nombre del archivo especificado:
var fs = require('fs');
fs.rename('mynewfile1.txt', 'myrenamedfile.txt', function (err) {
if (err) throw err;
console.log('File Renamed!');
});
Crea un archivo modulo_url.js y agrega la siguiente sintaxis:
var url = require('url');
var adr = 'http://tolinware.com/index.php?name=john&years=25';
var q = url.parse(adr, true);
console.log(q.host); //returns 'tolinware.com'
console.log(q.pathname); //returns '/index.php'
console.log(q.search); //returns '?name=john&years=25'
var qdata = q.query; //returns an object: { name: 'john', years: 25 }
console.log(qdata.name); //returns 'john'
Ejecutalo con node modulo_url.js y ve los resultados en consola.
Ahora haremos que se muestre el archivo solicitado por el cliente. Cree dos archivos html y guárdelos en la misma carpeta que sus archivos node.js.
Paso1. Crea un archivo html llamado mantenimiento_industrial.html
< !DOCTYPE html > < html > < body > < h1 >Mantenimiento industrial
Paso2. Crea un archivo html llamado tecnologias_produccion.html
< !DOCTYPE html > < html > < body > < h1 >Tecnologías de la producción
Paso3. Crea un archivo html llamado gestion.html
< !DOCTYPE html > < html > < body > < h1 >Gestión de Negocios y Proyectos
Paso4. Crea un archivo html llamado mecatronica.html
< !DOCTYPE html > < html > < body > < h1 >Mecatrónica
Paso5. Crea un archivo html llamado metal.html
< !DOCTYPE html > < html > < body > < h1 >Metal Mecánica
Paso6. Crea un archivo html llamado ti.html
< !DOCTYPE html > < html > < body > < h1 >Tecnologías de la Información
Cree un archivo Node.js llamado file_server.js que abra el archivo solicitado y devuelva el contenido al cliente. Si algo sale mal, arroja un error 404:
var http = require('http');
var url = require('url');
var fs = require('fs');
http.createServer(function (req, res) {
var q = url.parse(req.url, true);
var filename = "." + q.pathname;
fs.readFile(filename, function(err, data) {
if (err) {
res.writeHead(404, {'Content-Type': 'text/html'});
return res.end("404 Not Found");
}
res.writeHead(200, {'Content-Type': 'text/html'});
res.write(data);
return res.end();
});
}).listen(8080);
Ejecutalo con node modulo_url.js y ve los resultados en consola.
NPM es un administrador de paquetes y módulos para node.js. El programa de npm se instala en su computadora cuando instala node.js.
¿Qué es un paquete?Contenedores de archivos que se necesitan para los módulos. Los módulos son bibliotecas de JavaScript.
Descargando paquetesPara descargar un paquete solo se ingresa a la terminal y se escribe npm install seguido del nombre del paquete a descargar. En este caso se descargará el paquete upper-case que se utiliza para convertir texto en sólo mayúsculas.
Terminal ----------------------------------------- C:\Users\Your Name > npm install upper-case
Después solo se debe incluir el paquete en el script:
var uc = require('upper-case');
Este es un ejemplo de como se utiliza:
var http = require('http');
var uc = require('upper-case');
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
res.write(uc.upperCase("Hello World!"));
res.end();
}).listen(8080);
PAQUETES NPM PARA NODE.JS
Existen varios paquetes muy utilizados por los desarrolladores web. Da clic en la imagen para acceder a la lista de los paquetes más utilizados para desarrollos con node.js
Node.js es una aplicación de un solo subproceso, pero puede admitir la simultaneidad a través del concepto de eventos y devoluciones de llamada. Cada API de Node.js es asincrónica y está de un solo subproceso, usan llamadas de función asincrónicas para mantener la simultaneidad. El nodo utiliza el patrón del observador. El subproceso de nodo mantiene un bucle de eventos y cada vez que se completa una tarea, desencadena el evento correspondiente que indica la ejecución de la función de escucha de eventos.
PROGRAMACIÓN ORIENTADA A EVENTOSNode.js utiliza eventos en gran medida y también es una de las razones por las que Node.js es bastante rápido en comparación con otras tecnologías similares. Tan pronto como Node inicia su servidor, simplemente inicia sus variables, declara funciones y, a continuación, simplemente espera a que se produzca el evento.
En una aplicación controlada por eventos, generalmente hay un bucle principal que escucha eventos y, a continuación, desencadena una función de devolución de llamada cuando se detecta uno de esos eventos.
Aunque los eventos son bastante similares a las devoluciones de llamada, la diferencia radica en el hecho de que se llama a las funciones de devolución de llamada cuando una función asincrónica devuelve su resultado, mientras que el control de eventos funciona en el patrón de observador. Las funciones que escuchan eventos actúan como observadores. Cada vez que se desencadena un evento, su función de escucha comienza a ejecutarse. Node.js tiene varios eventos integrados disponibles a través del módulo de eventos y la clase EventEmitter, que se utilizan para enlazar eventos y detectores de eventos
EVENTOS EN NODE.JSCada acción en un equipo es un evento. Como cuando se realiza una conexión o se abre un archivo. Los objetos de node.js pueden desencadenar eventos, como el objeto readStream desencadena eventos al abrir y cerrar un archivo. Crea un archivo event1.js y copia el siguiente script y ejecutalo:
var fs = require('fs');
var rs = fs.createReadStream('./demofile.txt');
rs.on('open', function () {
console.log('The file is open');
});
MÓDULO DE EVENTOS
Node.js tiene un módulo integrado, llamado "Events", donde puede crear, disparar y escuchar sus propios eventos.
Para incluir el módulo Events integrado, utilice el método. Además, todas las propiedades y métodos de evento son una instancia de un objeto EventEmitter. Para poder acceder a estas propiedades y métodos, cree un EventEmitter object:require()
var events = require('events');
var eventEmitter = new events.EventEmitter();
EL OBJETO EVENTEMITTER
Puede asignar controladores de eventos a sus propios eventos con el objeto EventEmitter. En el ejemplo siguiente hemos creado una función que se ejecutará cuando se active un evento "scream". Para desencadenar un evento, utilice el método .emit()
Ejemplo1
var events = require('events');
var eventEmitter = new events.EventEmitter();
//Create an event handler:
var myEventHandler = function () {
console.log('I hear a scream!');
}
//Assign the event handler to an event:
eventEmitter.on('scream', myEventHandler);
//Fire the 'scream' event:
eventEmitter.emit('scream');
Ejemplo2
// Import events module
var events = require('events');
// Create an eventEmitter object
var eventEmitter = new events.EventEmitter();
// Create an event handler as follows
var connectHandler = function connected() {
console.log('connection succesful.');
// Fire the data_received event
eventEmitter.emit('data_received');
}
// Bind the connection event with the handler
eventEmitter.on('connection', connectHandler);
// Bind the data_received event with the anonymous function
eventEmitter.on('data_received', function(){
console.log('data received succesfully.');
});
// Fire the connection event
eventEmitter.emit('connection');
console.log("Program Ended.");
Paso1. Descarga el módulo formidable
Terminal ---------------------------- C:\Users\Your Name>npm install formidable
Paso2. Incluye el módulo de formidable en tu script:
var formidable = require('formidable');
Crea un formulario con un input text y input submit:
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
res.write(' < form action="fileupload" method="post" enctype="multipart/form-data">');
res.write(' < input type="file" name="filetoupload" > < br >');
res.write(' < input type="submit" > ');
res.write(' ');
return res.end();
}).listen(8080);
Paso3. Agrega una validación para colocarlo en una carpeta temporal:
if (req.url == '/fileupload') {
var form = new formidable.IncomingForm();
form.parse(req, function (err, fields, files) {
res.write('File uploaded');
res.end();
});
} else {
//Aquí va el código del formulario
}
Paso4. La ruta a este directorio se puede encontrar en el objeto "archivos", que se pasa como el tercer argumento en la parse()función de devolución de llamada del método. Para mover el archivo a la carpeta que elija, use el módulo Sistema de archivos y cambie el nombre del archivo:
SCRIPT COMPLETO
var http = require('http');
var formidable = require('formidable');
var fs = require('fs');
http.createServer(function (req, res) {
if (req.url == '/fileupload') {
var form = new formidable.IncomingForm();
form.parse(req, function (err, fields, files) {
var oldpath = files.filetoupload.path;
var newpath = 'C:/Users/Your Name/' + files.filetoupload.name;
fs.rename(oldpath, newpath, function (err) {
if (err) throw err;
res.write('File uploaded and moved!');
res.end();
});
});
} else {
res.writeHead(200, {'Content-Type': 'text/html'});
res.write(' < form action="fileupload" method="post" enctype="multipart/form-data">');
res.write(' < input type="file" name="filetoupload" > < br >');
res.write(' < input type="submit" > ');
res.write(' < /form > ');
return res.end();
}
}).listen(8080);
Ejecutalo y ve el resultado en el navegador.
Paso1. Instala el paquete nodemailer:
Terminal ---------------------- C:\Users\Your Name>npm install nodemailer
Paso2. Incluye en un archivo JavaScript nodemailer:
var nodemailer = require('nodemailer');
Paso3. Ahora está listo para enviar correos electrónicos desde su servidor. Use el nombre de usuario y la contraseña de su proveedor de correo electrónico seleccionado para enviar un correo electrónico. Este tutorial le mostrará cómo usar su cuenta de Gmail para enviar un correo electrónico:
var nodemailer = require('nodemailer');
var transporter = nodemailer.createTransport({
service: 'gmail',
auth: {
user: 'youremail@gmail.com',
pass: 'yourpassword'
}
});
var mailOptions = {
from: 'youremail@gmail.com',
to: 'myfriend@yahoo.com',
subject: 'Sending Email using Node.js',
text: 'That was easy!'
};
transporter.sendMail(mailOptions, function(error, info){
if (error) {
console.log(error);
} else {
console.log('Email sent: ' + info.response);
}
});
MÚLTIPLES RECEPTORES
Para enviar un correo electrónico a más de un receptor, agréguelos a la propiedad "para" del objeto mailOptions, separados por comas:
var mailOptions = {
from: 'youremail@gmail.com',
to: 'myfriend@yahoo.com, myotherfriend@yahoo.com',
subject: 'Sending Email using Node.js',
text: 'That was easy!'
}
ENVIAR HTML
Para enviar texto con formato HTML en su correo electrónico, use la propiedad "html" en lugar de la propiedad "texto":
var mailOptions = {
from: 'youremail@gmail.com',
to: 'myfriend@yahoo.com',
subject: 'Sending Email using Node.js',
html: '< h1 >Welcome< p >That was easy!'
}
Node.js se puede usar en aplicaciones de bases de datos. Una de las bases de datos más populares es MySQL.
Paso1. Instalar el controlador MySQLUna es que tenga MySQL en funcionamiento en su computadora, puede acceder a él utilizando Node.js. Para acceder a una base de datos MySQL con Node.js es necesario un controlador MySQL. A continuación se descargará el módulo "mysql" dede NPM:
Terminal ---------------------- C:\Users\Your Name>npm install mysqlPaso2. Incluye mysql en tu proyecto
Ahora ha descargado e instalado un controlador de base de datos mysql. Node.js puede usar este módulo para manipular la base de datos MySQL. Crea un archivo js llamado demo_db_connection.js e incluye lo siguiente:
var mysql = require('mysql');
Paso3. Crear conexión
Comienza creando una conexión de base de datos. Usa el nombre de usuario y contraseña:
var mysql = require('mysql');
var con = mysql.createConnection({
host: "localhost",
user: "yourusername",
password: "yourpassword"
});
con.connect(function(err) {
if (err) throw err;
console.log("Connected!");
});
Paso4. Comprueba la conexión
Ejecuta el archivo:
Terminal ----------------------- c:\Users\Your Name> node demo_bd_connection.js Connected!
Ahora puedes comenzar a consultar la base de datos.
Paso5. Consultar una base de datosUse sentencias SQL para leer (o escribir) en una base de datos MySQL. Esto también se llama "consultar" la base de datos. El objeto de conexión creado en el ejemplo anterior tiene un método para consultar la base de datos:
con.connect(function(err) {
if (err) throw err;
console.log("Connected!");
con.query(sql, function (err, result) {
if (err) throw err;
console.log("Result: " + result);
});
});
Creando una base de datos
Para crear una base de datos en MySQL, use la instrucción "CREATE DATABASE", copiando el siguiente código en un archivo llamado demo_create_db.js y ejecutalo con el comando node:
var mysql = require('mysql');
var con = mysql.createConnection({
host: "localhost",
user: "yourusername",
password: "yourpassword"
});
con.connect(function(err) {
if (err) throw err;
console.log("Connected!");
con.query("CREATE DATABASE mydb", function (err, result) {
if (err) throw err;
console.log("Database created");
});
});
Terminal ------------------------ C:\Users\Your Name>node demo_create_db.js Connected! Database createdCreando una tabla
Para crear una tabla en MySQL, use la instrucción "CREATE TABLE". Asegúrese de definir el nombre de la base de datos cuando cree la conexión. Copia el siguiente código en un archivo llamado demo_create_table.js y ejecútalo con el comando node:
var mysql = require('mysql');
var con = mysql.createConnection({
host: "localhost",
user: "yourusername",
password: "yourpassword",
database: "mydb"
});
con.connect(function(err) {
if (err) throw err;
console.log("Connected!");
var sql = "CREATE TABLE customers (name VARCHAR(255), address VARCHAR(255))";
con.query(sql, function (err, result) {
if (err) throw err;
console.log("Table created");
});
});
Terminal ------------------------ C:\Users\Your Name>node demo_create_table.js Connected! Table createdClave primaria
Al crear una tabla, también debe crear una columna con una clave única para cada registro. Esto se puede hacer definiendo una columna como "INT AUTO_INCREMENT PRIMARY KEY" que insertará un número único para cada registro. Comenzando en 1, y aumentado en uno por cada registro.
var mysql = require('mysql');
var con = mysql.createConnection({
host: "localhost",
user: "yourusername",
password: "yourpassword",
database: "mydb"
});
con.connect(function(err) {
if (err) throw err;
console.log("Connected!");
var sql = "CREATE TABLE customers (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255), address VARCHAR(255))";
con.query(sql, function (err, result) {
if (err) throw err;
console.log("Table created");
});
});
Modificar clave primaria
Si la tabla ya existe, use la palabra clave ALTER TABLE:
var mysql = require('mysql');
var con = mysql.createConnection({
host: "localhost",
user: "yourusername",
password: "yourpassword",
database: "mydb"
});
con.connect(function(err) {
if (err) throw err;
console.log("Connected!");
var sql = "ALTER TABLE customers ADD COLUMN id INT AUTO_INCREMENT PRIMARY KEY";
con.query(sql, function (err, result) {
if (err) throw err;
console.log("Table altered");
});
});
Insertar en la tabla
Para llenar una tabla en MySQL, use la instrucción "INSERTAR EN". Copia el siguiente código en un archivo llamado demo_insert_into.js
var mysql = require('mysql');
var con = mysql.createConnection({
host: "localhost",
user: "yourusername",
password: "yourpassword",
database: "mydb"
});
con.connect(function(err) {
if (err) throw err;
console.log("Connected!");
var sql = "INSERT INTO customers (name, address) VALUES ('Company Inc', 'Highway 37')";
con.query(sql, function (err, result) {
if (err) throw err;
console.log("1 record inserted");
});
});
Terminal ---------------------- C:\Users\Your Name>node demo_insert_into.js 1 record insertedInsertar múltiples registros
Para insertar más de un registro, haga una matriz que contenga los valores e inserte un signo de interrogación en el sql, que será reemplazado por la matriz de valores: INSERT INTO customers (name, address) VALUES ?
var mysql = require('mysql');
var con = mysql.createConnection({
host: "localhost",
user: "yourusername",
password: "yourpassword",
database: "mydb"
});
con.connect(function(err) {
if (err) throw err;
console.log("Connected!");
var sql = "INSERT INTO customers (name, address) VALUES ?";
var values = [
['John', 'Highway 71'],
['Peter', 'Lowstreet 4'],
['Amy', 'Apple st 652'],
['Hannah', 'Mountain 21'],
['Michael', 'Valley 345'],
['Sandy', 'Ocean blvd 2'],
['Betty', 'Green Grass 1'],
['Richard', 'Sky st 331'],
['Susan', 'One way 98'],
['Vicky', 'Yellow Garden 2'],
['Ben', 'Park Lane 38'],
['William', 'Central st 954'],
['Chuck', 'Main Road 989'],
['Viola', 'Sideway 1633']
];
con.query(sql, [values], function (err, result) {
if (err) throw err;
console.log("Number of records inserted: " + result.affectedRows);
});
});
Terminal ---------------------- C:\Users\Your Name>node demo_insert_multiple.js Connected! Number of records inserted: 14El objeto del resultado
Al ejecutar una consulta, se devuelve un objeto de resultado. El objeto resultante contiene información sobre cómo la consulta afectó a la tabla. El objeto de resultado devuelto del ejemplo anterior se ve así:
{
fieldCount: 0,
affectedRows: 14,
insertId: 0,
serverStatus: 2,
warningCount: 0,
message: '\'Records:14 Duplicated: 0 Warnings: 0',
protocol41: true,
changedRows: 0
}
Para devolver el número de filas afectadas:
console.log(result.affectedRows);
Lo que producirá este resultado:
14Obtener ID insertada
Para las tablas con un campo de identificación de incremento automático, puede obtener la identificación de la fila que acaba de insertar preguntando el objeto de resultado. Nota: Para poder obtener la identificación insertada, solo se puede insertar una fila .
var mysql = require('mysql');
var con = mysql.createConnection({
host: "localhost",
user: "yourusername",
password: "yourpassword",
database: "mydb"
});
con.connect(function(err) {
if (err) throw err;
var sql = "INSERT INTO customers (name, address) VALUES ('Michelle', 'Blue Village 1')";
con.query(sql, function (err, result) {
if (err) throw err;
console.log("1 record inserted, ID: " + result.insertId);
});
});
Guarda el anterior script en un archivo js llamado demo_db_insert.id.js y ejecutalo en node:
C:\Users\Your Name>node demo_db_insert_id.js 1 record inserted, ID: 15Selecionar una tabla
Para seleccionar datos de una tabla en MySQL, use la instrucción "SELECT".
var mysql = require('mysql');
var con = mysql.createConnection({
host: "localhost",
user: "yourusername",
password: "yourpassword",
database: "mydb"
});
con.connect(function(err) {
if (err) throw err;
con.query("SELECT * FROM customers", function (err, result, fields) {
if (err) throw err;
console.log(result);
});
});
Guarde el código anterior en un archivo llamado "demo_db_select.js" y ejecute el archivo, lo que te dará como resultado:
[
{ id: 1, name: 'John', address: 'Highway 71'},
{ id: 2, name: 'Peter', address: 'Lowstreet 4'},
{ id: 3, name: 'Amy', address: 'Apple st 652'},
{ id: 4, name: 'Hannah', address: 'Mountain 21'},
{ id: 5, name: 'Michael', address: 'Valley 345'},
{ id: 6, name: 'Sandy', address: 'Ocean blvd 2'},
{ id: 7, name: 'Betty', address: 'Green Grass 1'},
{ id: 8, name: 'Richard', address: 'Sky st 331'},
{ id: 9, name: 'Susan', address: 'One way 98'},
{ id: 10, name: 'Vicky', address: 'Yellow Garden 2'},
{ id: 11, name: 'Ben', address: 'Park Lane 38'},
{ id: 12, name: 'William', address: 'Central st 954'},
{ id: 13, name: 'Chuck', address: 'Main Road 989'},
{ id: 14, name: 'Viola', address: 'Sideway 1633'}
]
Como puede ver en el resultado del ejemplo anterior, el objeto resultante es una matriz que contiene cada fila como un objeto. Para devolver, por ejemplo, la dirección del tercer registro, simplemente consulte la propiedad de dirección del tercer objeto de matriz:
//Devuelva la dirección del tercer registro: console.log(result[2].address);
Terminal ---------------------- Apple st 652
Seleccione todos los registros de la tabla "clientes" y muestre el objeto con sus campos:
var mysql = require('mysql');
var con = mysql.createConnection({
host: "localhost",
user: "yourusername",
password: "yourpassword",
database: "mydb"
});
con.connect(function(err) {
if (err) throw err;
con.query("SELECT name, address FROM customers", function (err, result, fields) {
if (err) throw err;
console.log(fields);
});
});
Terminal
--------------------
C:\Users\Your Name > node demo_db_select_fields.js
[
{
catalog: 'def',
db: 'mydb',
table: 'customers',
orgTable: 'customers',
name: 'name',
orgName: 'address',
charsetNr: 33,
length: 765,
type: 253,
flags: 0,
decimals: 0,
default: undefined,
zeroFill: false,
protocol41: true
},
{
catalog: 'def',
db: 'mydb',
table: 'customers',
orgTable: 'customers',
name: 'address',
orgName: 'address',
charsetNr: 33,
length: 765,
type: 253,
flags: 0,
decimals: 0,
default: undefined,
zeroFill: false,
protocol41: true
{
]
Para devolver el nombre del segundo campo:
console.log(fields[1].name);
Terminal ------------------ adressSeleccionar con filtros
También puede seleccionar los registros que comienzan, incluyen o terminan con una letra o frase dada. Use el comodín '%' para representar cero, uno o varios caracteres. Ejemplo: Seleccione los registros donde la dirección comienza con la letra 'S':
var mysql = require('mysql');
var con = mysql.createConnection({
host: "localhost",
user: "yourusername",
password: "yourpassword",
database: "mydb"
});
con.connect(function(err) {
if (err) throw err;
con.query("SELECT * FROM customers WHERE address LIKE 'S%'", function (err, result) {
if (err) throw err;
console.log(result);
});
});
Terminal
---------------------
C:\Users\Your Name>node demo_db_where_s.js
[
{ id: 8, name: 'Richard', address: 'Sky st 331'},
{ id: 14, name: 'Viola', address: 'Sideway 1633'}
]
Eliminar registro
Puede eliminar registros de una tabla existente utilizando la instrucción "DELETE FROM". Ejemplo: Eliminar cualquier registro con la dirección "Mountain 21":
var mysql = require('mysql');
var con = mysql.createConnection({
host: "localhost",
user: "yourusername",
password: "yourpassword",
database: "mydb"
});
con.connect(function(err) {
if (err) throw err;
var sql = "DELETE FROM customers WHERE address = 'Mountain 21'";
con.query(sql, function (err, result) {
if (err) throw err;
console.log("Number of records deleted: " + result.affectedRows);
});
});
Terminal -------------------- C:\Users\Your Name>node demo_db_delete.js Number of records deleted: 1Eliminar una tabla
Puede eliminar una tabla existente utilizando la instrucción "DROP TABLE". Ejemplo: Eliminar la tabla "clientes":
var mysql = require('mysql');
var con = mysql.createConnection({
host: "localhost",
user: "yourusername",
password: "yourpassword",
database: "mydb"
});
con.connect(function(err) {
if (err) throw err;
var sql = "DROP TABLE IF EXISTS customers";
con.query(sql, function (err, result) {
if (err) throw err;
console.log("Table deleted");
});
});
Terminal ---------------------- C:\Users\Your Name > node demo_db_drop_table.js Table deletedActualizar registros de la tabla
Puede actualizar los registros existentes en una tabla utilizando la instrucción "ACTUALIZAR". Ejemplo: Sobrescriba la columna de dirección de "Valley 345" a "Canyon 123":
var mysql = require('mysql');
var con = mysql.createConnection({
host: "localhost",
user: "yourusername",
password: "yourpassword",
database: "mydb"
});
con.connect(function(err) {
if (err) throw err;
var sql = "UPDATE customers SET address = 'Canyon 123' WHERE address = 'Valley 345'";
con.query(sql, function (err, result) {
if (err) throw err;
console.log(result.affectedRows + " record(s) updated");
});
});
Observe la cláusula WHERE en la sintaxis UPDATE: la cláusula WHERE especifica qué registro o registros deben actualizarse. Si omite la cláusula WHERE, todos los registros se actualizarán.
Terminal ----------------- C:\Users\Your Name>node demo_db_update.js 1 record(s) updatedNode.js MySQL Join
Puede combinar filas de dos o más tablas, en función de una columna relacionada entre ellas, utilizando una instrucción JOIN. Considere que tiene una tabla de "usuarios" y una tabla de "productos":
Tabla usuarios:
[
{ id: 1, name: 'John', favorite_product: 154},
{ id: 2, name: 'Peter', favorite_product: 154},
{ id: 3, name: 'Amy', favorite_product: 155},
{ id: 4, name: 'Hannah', favorite_product:},
{ id: 5, name: 'Michael', favorite_product:}
]
Tabla productos:
[
{ id: 154, name: 'Chocolate Heaven' },
{ id: 155, name: 'Tasty Lemons' },
{ id: 156, name: 'Vanilla Dreams' }
]
Estas dos tablas se pueden combinar utilizando el favorite_productcampo de usuarios y el campo de productos id. Ejemplo: Seleccione registros con una coincidencia en ambas tablas:
var mysql = require('mysql');
var con = mysql.createConnection({
host: "localhost",
user: "yourusername",
password: "yourpassword",
database: "mydb"
});
con.connect(function(err) {
if (err) throw err;
var sql = "SELECT users.name AS user, products.name AS favorite FROM users JOIN products ON users.favorite_product = products.id";
con.query(sql, function (err, result) {
if (err) throw err;
console.log(result);
});
});
Terminal
----------------
C:\Users\Your Name>node demo_db_join.js
[
{ user: 'John', favorite: 'Chocolate Heaven' },
{ user: 'Peter', favorite: 'Chocolate Heaven' },
{ user: 'Amy', favorite: 'Tasty Lemons' }
]
Para poder experimentar con los ejemplos de código, necesitará acceso a una base de datos MongoDB. Puede descargar una base de datos gratuita de MongoDB en mongodb.
Paso1. Instalar el controlador MySQLIntentemos acceder a una base de datos MongoDB con Node.js. Para descargar e instalar el controlador oficial MongoDB, abra la Terminal de comandos y ejecute lo siguiente:
Terminal ---------------------- C:\Users\Your Name>npm install mongodbPaso2. Incluye mondodb en tu proyecto
Ahora ha descargado e instalado un controlador de base de datos mongodb. Node.js puede usar este módulo para manipular bases de datos MongoDB:
var mongo = require('mongodb');
Paso3. Crear una base de datos
Para crear una base de datos en MongoDB, comience creando un objeto MongoClient, luego especifique una URL de conexión con la dirección IP correcta y el nombre de la base de datos que desea crear. MongoDB creará la base de datos si no existe y establecerá una conexión con ella.
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/mydb";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
console.log("Database created!");
db.close();
});
Paso4. Ejecuta la creación de base de datos
Ejecuta el archivo:
Terminal ----------------------- c:\Users\Your Name> node demo_create_mongo_db.js Database created!
Importante: En MongoDB, una base de datos no se crea hasta que obtiene contenido!
MongoDB espera hasta que haya creado una colección (tabla), con al menos un documento (registro) antes de que realmente cree la base de datos (y la colección).
Paso5. Creando una colecciónPara crear una colección en MongoDB, use el método createCollection():
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
dbo.createCollection("customers", function(err, res) {
if (err) throw err;
console.log("Collection created!");
db.close();
});
});
Guarde el código anterior en un archivo llamado "demo_mongodb_createcollection.js" y ejecute el archivo:
Terminal ---------------------- C:\Users\Your Name>node demo_mongodb_createcollection.js Collection created!
Importante: ¡En MongoDB, una colección no se crea hasta que obtiene contenido!
MongoDB espera hasta que haya insertado un documento antes de que realmente cree la colección.
Insertar en la colecciónPara insertar un registro o documento como se llama en MongoDB, en una colección, utilizamos el método insertOne(). Un documento en MongoDB es lo mismo que un registro en MySQL. El primer parámetro del insertOne()método es un objeto que contiene los nombres y los valores de cada campo en el documento que desea insertar. También toma una función de devolución de llamada donde puede trabajar con cualquier error o el resultado de la inserción:
//Inserte un documento en la colección "clientes":
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
var myobj = { name: "Company Inc", address: "Highway 37" };
dbo.collection("customers").insertOne(myobj, function(err, res) {
if (err) throw err;
console.log("1 document inserted");
db.close();
});
});
Guarde el código anterior en un archivo llamado "demo_mongodb_insert.js" y ejecute el archivo:
Terminal ------------------------ C:\Users\Your Name>node demo_mongodb_insert.js 1 document inserted
Nota: Si intenta insertar documentos en una colección que no existe, MongoDB creará la colección automáticamente.
Insertar múltiples documentosPara insertar múltiples documentos en una colección en MongoDB, utilizamos el método insertMany(). El primer parámetro del método insertMany() es una matriz de objetos que contiene los datos que desea insertar. También toma una función de devolución de llamada donde puede trabajar con cualquier error o el resultado de la inserción:
Inserte varios documentos en la colección "clientes":
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
var myobj = [
{ name: 'John', address: 'Highway 71'},
{ name: 'Peter', address: 'Lowstreet 4'},
{ name: 'Amy', address: 'Apple st 652'},
{ name: 'Hannah', address: 'Mountain 21'},
{ name: 'Michael', address: 'Valley 345'},
{ name: 'Sandy', address: 'Ocean blvd 2'},
{ name: 'Betty', address: 'Green Grass 1'},
{ name: 'Richard', address: 'Sky st 331'},
{ name: 'Susan', address: 'One way 98'},
{ name: 'Vicky', address: 'Yellow Garden 2'},
{ name: 'Ben', address: 'Park Lane 38'},
{ name: 'William', address: 'Central st 954'},
{ name: 'Chuck', address: 'Main Road 989'},
{ name: 'Viola', address: 'Sideway 1633'}
];
dbo.collection("customers").insertMany(myobj, function(err, res) {
if (err) throw err;
console.log("Number of documents inserted: " + res.insertedCount);
db.close();
});
});
Guarde el código anterior en un archivo llamado "demo_mongodb_insert_multiple.js" y ejecute el archivo:
C:\Users\Your Name>node demo_mongodb_insert_multiple.js Number of documents inserted: 14El objeto del resultado
Al ejecutar el método insertMany(), se devuelve un objeto de resultado. El objeto resultante contiene información sobre cómo la inserción afectó a la base de datos. El objeto devuelto del ejemplo anterior se veía así:
{
result: { ok: 1, n: 14 },
ops: [
{ name: 'John', address: 'Highway 71', _id: 58fdbf5c0ef8a50b4cdd9a84 },
{ name: 'Peter', address: 'Lowstreet 4', _id: 58fdbf5c0ef8a50b4cdd9a85 },
{ name: 'Amy', address: 'Apple st 652', _id: 58fdbf5c0ef8a50b4cdd9a86 },
{ name: 'Hannah', address: 'Mountain 21', _id: 58fdbf5c0ef8a50b4cdd9a87 },
{ name: 'Michael', address: 'Valley 345', _id: 58fdbf5c0ef8a50b4cdd9a88 },
{ name: 'Sandy', address: 'Ocean blvd 2', _id: 58fdbf5c0ef8a50b4cdd9a89 },
{ name: 'Betty', address: 'Green Grass 1', _id: 58fdbf5c0ef8a50b4cdd9a8a },
{ name: 'Richard', address: 'Sky st 331', _id: 58fdbf5c0ef8a50b4cdd9a8b },
{ name: 'Susan', address: 'One way 98', _id: 58fdbf5c0ef8a50b4cdd9a8c },
{ name: 'Vicky', address: 'Yellow Garden 2', _id: 58fdbf5c0ef8a50b4cdd9a8d },
{ name: 'Ben', address: 'Park Lane 38', _id: 58fdbf5c0ef8a50b4cdd9a8e },
{ name: 'William', address: 'Central st 954', _id: 58fdbf5c0ef8a50b4cdd9a8f },
{ name: 'Chuck', address: 'Main Road 989', _id: 58fdbf5c0ef8a50b4cdd9a90 },
{ name: 'Viola', address: 'Sideway 1633', _id: 58fdbf5c0ef8a50b4cdd9a91 } ],
insertedCount: 14,
insertedIds: [
58fdbf5c0ef8a50b4cdd9a84,
58fdbf5c0ef8a50b4cdd9a85,
58fdbf5c0ef8a50b4cdd9a86,
58fdbf5c0ef8a50b4cdd9a87,
58fdbf5c0ef8a50b4cdd9a88,
58fdbf5c0ef8a50b4cdd9a89,
58fdbf5c0ef8a50b4cdd9a8a,
58fdbf5c0ef8a50b4cdd9a8b,
58fdbf5c0ef8a50b4cdd9a8c,
58fdbf5c0ef8a50b4cdd9a8d,
58fdbf5c0ef8a50b4cdd9a8e,
58fdbf5c0ef8a50b4cdd9a8f
58fdbf5c0ef8a50b4cdd9a90,
58fdbf5c0ef8a50b4cdd9a91 ]
}
Los valores de las propiedades se pueden mostrar así:
Devuelve el número de documentos insertados:
console.log(res.insertedCount)
Lo que producirá este resultado:
14El campo _id
Si no especifica un campo _id, MongoDB agregará uno para usted y le asignará una identificación única para cada documento. En el ejemplo anterior, el _id no se especificó ningún campo y, como puede ver en el objeto de resultado, MongoDB asignó un único _id para cada documento. Si haces especificar el campo _id, el valor debe ser único para cada documento:
Inserte tres registros en una tabla de "productos", con _idcampos específicos:
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
var myobj = [
{ _id: 154, name: 'Chocolate Heaven'},
{ _id: 155, name: 'Tasty Lemon'},
{ _id: 156, name: 'Vanilla Dream'}
];
dbo.collection("products").insertMany(myobj, function(err, res) {
if (err) throw err;
console.log(res);
db.close();
});
});
Guarde el código anterior en un archivo llamado "demo_mongodb_insert_id.js" y ejecute el archivo:
Terminal
----------------------
C:\Users\Your Name>node demo_mongodb_insert_id.js
{
result: { ok: 1, n: 3 },
ops: [
{ _id: 154, name: 'Chocolate Heaven },
{ _id: 155, name: 'Tasty Lemon },
{ _id: 156, name: 'Vanilla Dream } ],
insertedCount: 3,
insertedIds: [
154,
155,
156 ]
}
Buscar: encontrar uno
Para seleccionar datos de una colección en MongoDB, podemos usar el método findOne(). El método findOne() devuelve la primera aparición en la selección. El primer parámetro del método findOne() es un objeto de consulta. En este ejemplo, usamos un objeto de consulta vacío, que selecciona todos los documentos de una colección (pero devuelve solo el primer documento).
Encuentre el primer documento en la colección de clientes:
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
dbo.collection("customers").findOne({}, function(err, result) {
if (err) throw err;
console.log(result.name);
db.close();
});
});
Guarde el código anterior en un archivo llamado "demo_mongodb_findone.js" y ejecute el archivo:
Terminal ---------------------- C:\Users\Your Name>node demo_mongodb_findone.js Company Inc.Buscar: encuentra uno
Para seleccionar datos de una tabla en MongoDB, también podemos usar el método find(). El método find() devuelve todas las ocurrencias en la selección. El primer parámetro del método find() es un objeto de consulta. En este ejemplo, usamos un objeto de consulta vacío, que selecciona todos los documentos de la colección.
Ningún parámetro en el método find() le da el mismo resultado que SELECT * en MySQL.
Encuentre todos los documentos en la colección de clientes:
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
dbo.collection("customers").find({}).toArray(function(err, result) {
if (err) throw err;
console.log(result);
db.close();
});
});
Guarde el código anterior en un archivo llamado "demo_mongodb_find.js" y ejecute el archivo:
Terminal
-----------------
C:\Users\Your Name>node demo_mongodb_find.js
[
{ _id: 58fdbf5c0ef8a50b4cdd9a84 , name: 'John', address: 'Highway 71'},
{ _id: 58fdbf5c0ef8a50b4cdd9a85 , name: 'Peter', address: 'Lowstreet 4'},
{ _id: 58fdbf5c0ef8a50b4cdd9a86 , name: 'Amy', address: 'Apple st 652'},
{ _id: 58fdbf5c0ef8a50b4cdd9a87 , name: 'Hannah', address: 'Mountain 21'},
{ _id: 58fdbf5c0ef8a50b4cdd9a88 , name: 'Michael', address: 'Valley 345'},
{ _id: 58fdbf5c0ef8a50b4cdd9a89 , name: 'Sandy', address: 'Ocean blvd 2'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8a , name: 'Betty', address: 'Green Grass 1'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8b , name: 'Richard', address: 'Sky st 331'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8c , name: 'Susan', address: 'One way 98'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8d , name: 'Vicky', address: 'Yellow Garden 2'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8e , name: 'Ben', address: 'Park Lane 38'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8f , name: 'William', address: 'Central st 954'},
{ _id: 58fdbf5c0ef8a50b4cdd9a90 , name: 'Chuck', address: 'Main Road 989'},
{ _id: 58fdbf5c0ef8a50b4cdd9a91 , name: 'Viola', address: 'Sideway 1633'}
]
Encuentra algo
El segundo parámetro del método find() es el projectionobjeto que describe qué campos incluir en el resultado. Este parámetro es opcional y, si se omite, todos los campos se incluirán en el resultado.
Devuelva los campos "nombre" y "dirección" de todos los documentos en la colección de clientes:
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
dbo.collection("customers").find({}, { projection: { _id: 0, name: 1, address: 1 } }).toArray(function(err, result) {
if (err) throw err;
console.log(result);
db.close();
});
});
Guarde el código anterior en un archivo llamado "demo_mongodb_find_fields.js" y ejecute el archivo:
Terminal
-----------------
C:\Users\Your Name>node demo_mongodb_find_fields.js
[
{ name: 'John', address: 'Highway 71'},
{ name: 'Peter', address: 'Lowstreet 4'},
{ name: 'Amy', address: 'Apple st 652'},
{ name: 'Hannah', address: 'Mountain 21'},
{ name: 'Michael', address: 'Valley 345'},
{ name: 'Sandy', address: 'Ocean blvd 2'},
{ name: 'Betty', address: 'Green Grass 1'},
{ name: 'Richard', address: 'Sky st 331'},
{ name: 'Susan', address: 'One way 98'},
{ name: 'Vicky', address: 'Yellow Garden 2'},
{ name: 'Ben', address: 'Park Lane 38'},
{ name: 'William', address: 'Central st 954'},
{ name: 'Chuck', address: 'Main Road 989'},
{ name: 'Viola', address: 'Sideway 1633'}
]
No está permitido especificar valores 0 y 1 en el mismo objeto (excepto si uno de los campos es el campo _id). Si especifica un campo con el valor 0, todos los demás campos obtienen el valor 1 y viceversa:
Este ejemplo excluirá "dirección" del resultado:
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
dbo.collection("customers").find({}, { projection: { address: 0 } }).toArray(function(err, result) {
if (err) throw err;
console.log(result);
db.close();
});
});
Para excluir el campo _id, debe establecer su valor en 0:
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
dbo.collection("customers").find({}, { projection: { _id: 0, name: 1 } }).toArray(function(err, result) {
if (err) throw err;
console.log(result);
db.close();
});
});
Este ejemplo le dará el mismo resultado que el primer ejemplo; devolver todos los campos excepto el campo _id:
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
dbo.collection("customers").find({}, { projection: { _id: 0 } }).toArray(function(err, result) {
if (err) throw err;
console.log(result);
db.close();
});
});
Filtrar el resultado
Al buscar documentos en una colección, puede filtrar el resultado utilizando un objeto de consulta. El primer argumento del método find() es un objeto de consulta y se utiliza para limitar la búsqueda.
Busque documentos con la dirección "Park Lane 38":
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
var query = { address: "Park Lane 38" };
dbo.collection("customers").find(query).toArray(function(err, result) {
if (err) throw err;
console.log(result);
db.close();
});
});
Guarde el código anterior en un archivo llamado "demo_mongodb_query.js" y ejecute el archivo:
Terminal
-----------------
C:\Users\Your Name>node demo_mongodb_query.js
[
{ _id: 58fdbf5c0ef8a50b4cdd9a8e , name: 'Ben', address: 'Park Lane 38' }
]
Filtrar expresiones regulares
Puede escribir expresiones regulares para encontrar exactamente lo que está buscando.
Las expresiones regulares solo se pueden usar para consultar cadenas.
Para buscar solo los documentos donde el campo "dirección" comienza con la letra "S", use la expresión regular /^S/:
Encuentre documentos donde la dirección comienza con la letra "S":
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
var query = { address: /^S/ };
dbo.collection("customers").find(query).toArray(function(err, result) {
if (err) throw err;
console.log(result);
db.close();
});
});
Terminal
--------------------
C:\Users\Your Name>node demo_mongodb_query_s.js
[
{ _id: 58fdbf5c0ef8a50b4cdd9a8b , name: 'Richard', address: 'Sky st 331' },
{ _id: 58fdbf5c0ef8a50b4cdd9a91 , name: 'Viola', address: 'Sideway 1633' }
]
Ordenar el resultado
Use el método sort() para ordenar el resultado en orden ascendente o descendente. El método sort() toma un parámetro, un objeto que define el orden de clasificación.
Ordenar el resultado alfabéticamente por nombre:
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
var mysort = { name: 1 };
dbo.collection("customers").find().sort(mysort).toArray(function(err, result) {
if (err) throw err;
console.log(result);
db.close();
});
});
Terminal
------------------
C:\Users\Your Name>node demo_sort.js
[
{ _id: 58fdbf5c0ef8a50b4cdd9a86, name: 'Amy', address: 'Apple st 652'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8e, name: 'Ben', address: 'Park Lane 38'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8a, name: 'Betty', address: 'Green Grass 1'},
{ _id: 58fdbf5c0ef8a50b4cdd9a90, name: 'Chuck', address: 'Main Road 989'},
{ _id: 58fdbf5c0ef8a50b4cdd9a87, name: 'Hannah', address: 'Mountain 21'},
{ _id: 58fdbf5c0ef8a50b4cdd9a84, name: 'John', address: 'Highway 71'},
{ _id: 58fdbf5c0ef8a50b4cdd9a88, name: 'Michael', address: 'Valley 345'},
{ _id: 58fdbf5c0ef8a50b4cdd9a85, name: 'Peter', address: 'Lowstreet 4'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8b, name: 'Richard', address: 'Sky st 331'},
{ _id: 58fdbf5c0ef8a50b4cdd9a89, name: 'Sandy', address: 'Ocean blvd 2'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8c, name: 'Susan', address: 'One way 98'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8d, name: 'Vicky', address: 'Yellow Garden 2'},
{ _id: 58fdbf5c0ef8a50b4cdd9a91, name: 'Viola', address: 'Sideway 1633'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8f, name: 'William', address: 'Central st 954'}
]
Orden descendiente
Use el valor -1 en el objeto de clasificación para ordenar descendente.
{nombre: 1} // ascendente
{nombre: -1} // descendente
Ejemplo: Ordenar el resultado en orden alfabético por nombre:
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
var mysort = { name: -1 };
dbo.collection("customers").find().sort(mysort).toArray(function(err, result) {
if (err) throw err;
console.log(result);
db.close();
});
});
Guarde el código anterior en un archivo llamado "demo_sort_desc.js" y ejecute el archivo:
Terminal
---------------------
C:\Users\Your Name>node demo_sort_desc.js
[
{ _id: 58fdbf5c0ef8a50b4cdd9a8f, name: 'William', address: 'Central st 954'},
{ _id: 58fdbf5c0ef8a50b4cdd9a91, name: 'Viola', address: 'Sideway 1633'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8d, name: 'Vicky', address: 'Yellow Garden 2'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8c, name: 'Susan', address: 'One way 98'},
{ _id: 58fdbf5c0ef8a50b4cdd9a89, name: 'Sandy', address: 'Ocean blvd 2'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8b, name: 'Richard', address: 'Sky st 331'},
{ _id: 58fdbf5c0ef8a50b4cdd9a85, name: 'Peter', address: 'Lowstreet 4'},
{ _id: 58fdbf5c0ef8a50b4cdd9a88, name: 'Michael', address: 'Valley 345'},
{ _id: 58fdbf5c0ef8a50b4cdd9a84, name: 'John', address: 'Highway 71'},
{ _id: 58fdbf5c0ef8a50b4cdd9a87, name: 'Hannah', address: 'Mountain 21'},
{ _id: 58fdbf5c0ef8a50b4cdd9a90, name: 'Chuck', address: 'Main Road 989'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8a, name: 'Betty', address: 'Green Grass 1'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8e, name: 'Ben', address: 'Park Lane 38'},
{ _id: 58fdbf5c0ef8a50b4cdd9a86, name: 'Amy', address: 'Apple st 652'}
]
Eliminar documento
Para eliminar un registro o documento como se llama en MongoDB, utilizamos el método deleteOne(). El primer parámetro del método deleteOne() es un objeto de consulta que define qué documento eliminar.
Nota: Si la consulta encuentra más de un documento, solo se elimina la primera aparición.
Ejemplo: Eliminar el documento con la dirección "Mountain 21":
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
var myquery = { address: 'Mountain 21' };
dbo.collection("customers").deleteOne(myquery, function(err, obj) {
if (err) throw err;
console.log("1 document deleted");
db.close();
});
});
Terminal -------------------- C:\Users\Your Name>node demo_delete.js 1 document deletedEliminar muchos
Para eliminar más de un documento, use el método deleteMany(). El primer parámetro del método deleteMany() es un objeto de consulta que define qué documentos eliminar.
Ejemplo: Eliminar todos los documentos donde la dirección comienza con la letra "O":
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
var myquery = { address: /^O/ };
dbo.collection("customers").deleteMany(myquery, function(err, obj) {
if (err) throw err;
console.log(obj.result.n + " document(s) deleted");
db.close();
});
});
Terminal ---------------------- C:\Users\Your Name>node demo_delete_many.js 2 document(s) deletedBorrar colección
Puede eliminar una tabla o colección como se llama en MongoDB, utilizando el método drop(). El método drop() toma una función de devolución de llamada que contiene el objeto de error y el parámetro de resultado que devuelve verdadero si la colección se descartó correctamente; de lo contrario, devuelve falso.
Ejemplo: Eliminar la tabla "clientes":
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
dbo.collection("customers").drop(function(err, delOK) {
if (err) throw err;
if (delOK) console.log("Collection deleted");
db.close();
});
});
Guarde el código anterior en un archivo llamado "demo_drop.js" y ejecute el archivo:
Terminal ----------------- C:\Users\Your Name>node demo_drop.js Collection deleteddb.dropCollection
También puede usar el método dropCollection() para eliminar una tabla (colección). El método dropCollection() toma dos parámetros: el nombre de la colección y una función de devolución de llamada.
Ejemplo: Eliminar la colección "clientes", usando dropCollection():
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
dbo.dropCollection("customers", function(err, delOK) {
if (err) throw err;
if (delOK) console.log("Collection deleted");
db.close();
});
});
Guarde el código anterior en un archivo llamado "demo_dropcollection.js" y ejecute el archivo:
Terminal ---------------- C:\Users\Your Name>node demo_dropcollection.js Collection deletedActualizar documento
Puede actualizar un registro o documento como se llama en MongoDB, utilizando el método updateOne(). El primer parámetro del método updateOne() es un objeto de consulta que define qué documento actualizar.
Nota: Si la consulta encuentra más de un registro, solo se actualiza la primera aparición.
El segundo parámetro es un objeto que define los nuevos valores del documento.
Ejemplo: Actualice el documento con la dirección "Valley 345" a name = "Mickey" y address = "Canyon 123":
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://127.0.0.1:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
var myquery = { address: "Valley 345" };
var newvalues = { $set: {name: "Mickey", address: "Canyon 123" } };
dbo.collection("customers").updateOne(myquery, newvalues, function(err, res) {
if (err) throw err;
console.log("1 document updated");
db.close();
});
});
Terminal ---------------- C:\Users\Your Name>node demo_update_one.js 1 document updatedActualizar solo campos especificos
Cuando se utiliza el operador $set, solo se actualizan los campos especificados:
Ejemplo: Actualice la dirección de "Valley 345" a "Canyon 123":
...
var myquery = { address: "Valley 345" };
var newvalues = { $set: { address: "Canyon 123" } };
dbo.collection("customers").updateOne(myquery, newvalues, function(err, res) {
...
Actualizar muchos
Para actualizar todos los documentos que cumplan los criterios de la consulta, utilice el método updateMany():
Ejemplo: Actualice todos los documentos donde el nombre comienza con la letra "S":
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://127.0.0.1:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
var myquery = { address: /^S/ };
var newvalues = {$set: {name: "Minnie"} };
dbo.collection("customers").updateMany(myquery, newvalues, function(err, res) {
if (err) throw err;
console.log(res.result.nModified + " document(s) updated");
db.close();
});
});
Guarde el código anterior en un archivo llamado "demo_update_many.js" y ejecute el archivo:
Terminal ------------------- C:\Users\Your Name>node demo_update_many.js 2 document(s) updatedEl objeto del resultado
El updateOne() y los updateMany() métodos de devolución de un objeto que contiene información acerca de cómo afecta la ejecución de la base de datos. La mayoría de la información no es importante de entender, pero un objeto dentro del objeto se llama "resultado", que nos dice si la ejecución fue correcta y cuántos documentos se vieron afectados. El objeto resultante se ve así:
{ n: 1, nModified: 2, ok: 1 }
Ejemplo: Devuelve el número de documentos actualizados:
console.log(res.result.nModified);
2Limitar el resultado
Para limitar el resultado en MongoDB, utilizamos el método limit(). El método limit() toma un parámetro, un número que define cuántos documentos devolver. Considere que tiene una colección de "clientes":
[
{ _id: 58fdbf5c0ef8a50b4cdd9a84 , name: 'John', address: 'Highway 71'},
{ _id: 58fdbf5c0ef8a50b4cdd9a85 , name: 'Peter', address: 'Lowstreet 4'},
{ _id: 58fdbf5c0ef8a50b4cdd9a86 , name: 'Amy', address: 'Apple st 652'},
{ _id: 58fdbf5c0ef8a50b4cdd9a87 , name: 'Hannah', address: 'Mountain 21'},
{ _id: 58fdbf5c0ef8a50b4cdd9a88 , name: 'Michael', address: 'Valley 345'},
{ _id: 58fdbf5c0ef8a50b4cdd9a89 , name: 'Sandy', address: 'Ocean blvd 2'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8a , name: 'Betty', address: 'Green Grass 1'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8b , name: 'Richard', address: 'Sky st 331'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8c , name: 'Susan', address: 'One way 98'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8d , name: 'Vicky', address: 'Yellow Garden 2'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8e , name: 'Ben', address: 'Park Lane 38'},
{ _id: 58fdbf5c0ef8a50b4cdd9a8f , name: 'William', address: 'Central st 954'},
{ _id: 58fdbf5c0ef8a50b4cdd9a90 , name: 'Chuck', address: 'Main Road 989'},
{ _id: 58fdbf5c0ef8a50b4cdd9a91 , name: 'Viola', address: 'Sideway 1633'}
]
Ejemplo. Limite el resultado para que solo devuelva 5 documentos:
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
dbo.collection("customers").find().limit(5).toArray(function(err, result) {
if (err) throw err;
console.log(result);
db.close();
});
});
Guarde el código anterior en un archivo llamado "demo_mongodb_limit.js" y ejecute el archivo:
Terminal -------------------- C:\Users\Your Name>node demo_mongodb_limit.js
Lo que te dará este resultado:
[
{ _id: 58fdbf5c0ef8a50b4cdd9a84 , name: 'John', address: 'Highway 71'},
{ _id: 58fdbf5c0ef8a50b4cdd9a85 , name: 'Peter', address: 'Lowstreet 4'},
{ _id: 58fdbf5c0ef8a50b4cdd9a86 , name: 'Amy', address: 'Apple st 652'},
{ _id: 58fdbf5c0ef8a50b4cdd9a87 , name: 'Hannah', address: 'Mountain 21'},
{ _id: 58fdbf5c0ef8a50b4cdd9a88 , name: 'Michael', address: 'Valley 345'}
]
Como puede ver en el resultado anterior, solo se devolvieron los 5 primeros documentos.
Unión de coleccionesMongoDB no es una base de datos relacional, pero puede realizar una unión externa izquierda utilizando $lookup. $lookup le permite especificar qué colección desea unir con la colección actual y qué campos deben coincidir. Considere que tiene una colección de "pedidos" y una colección de "productos":
pedidos
----------------
[
{ _id: 1, product_id: 154, status: 1 }
]
productos
----------------
[
{ _id: 154, name: 'Chocolate Heaven' },
{ _id: 155, name: 'Tasty Lemons' },
{ _id: 156, name: 'Vanilla Dreams' }
]
Ejemplo: Unir los documentos de "productos" correspondientes a la colección "pedidos":
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://127.0.0.1:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("mydb");
dbo.collection('orders').aggregate([
{ $lookup:
{
from: 'products',
localField: 'product_id',
foreignField: '_id',
as: 'orderdetails'
}
}
]).toArray(function(err, res) {
if (err) throw err;
console.log(JSON.stringify(res));
db.close();
});
});
Guarde el código anterior en un archivo llamado "demo_mongodb_join.js" y ejecute el archivo:
Terminal
------------
C:\Users\Your Name>node demo_mongodb_join.js
[
{ "_id": 1, "product_id": 154, "status": 1, "orderdetails": [
{ "_id": 154, "name": "Chocolate Heaven" } ]
}
]
Como puede ver en el resultado anterior, el documento correspondiente de la colección de productos se incluye en la colección de pedidos como una matriz.
Una API es una interfaz de programación de aplicaciones. Es un conjunto de reglas que permiten que los programas se comuniquen entre sí. El desarrollador crea la API en el servidor y permite que el cliente le hable.
REST determina cómo se ve la API. Es sinónimo de "Transferencia de Estado de representación" Es un conjunto de reglas que los desarrolladores siguen cuando crean su API. Una de estas reglas establece que debe poder obtener un dato (llamado recurso) cuando se vincula a una URL específica.
Cada URL se denomina solicitud, mientras que los datos que se le devuelven se denominan respuesta. - smashingmagazine.com
Paso1. Iniciar el proyectoAhora es el momento de comenzar a trabajar en nuestro proyecto. En primer lugar, crearemos una carpeta llamada FirstRest y vamos dentro de ella.
Terminal ------------------ C:\Users\Your Name > mkdir FirstRest C:\Users\Your Name > cd FirstRest
Ahora dentro de la carpeta FirstRest inicializamos nuestro proyecto node.js con npm init.
Terminal ------------------ C:\Users\Your Name\FirstRest > npm init
Al iniciar el node.js, se le preguntarán cosas diferentes. Solo tiene que elegir el nombre predeterminado, agregar la descripción, agregar el nombre del autor y elegir la licencia predeterminada para generar package.json. Si ha cometido algún error, no se preocupe, puede cambiarlo después. Después de completar la operación, verá la siguiente pantalla.
Terminal ------------------ C:\Users\Your Name\FirstRest > npm init . . . Is this OK? (yes) yes C:\Users\Your Name\FirstRest >Paso2. Instalando Express
Instalemos express y configuremos el servidor. Necesitamos ejecutar el servidor para que nuestra API sea accesible para el navegador web o las herramientas para probar la API como Postman.
Terminal ---------------- C:\Users\Your Name\FirstRest > npm install express --save
El comando anterior instalará las dependencias.
Paso3. Creando el archivo de inicio index.jsDespués de seguir los pasos anteriores se puede observar el directorio node_modules y el archivo package.json en el proyecto. Ahora debemos crear un archivo llamado index.js que será nuestro archivo de entrada. Agreguemos el siguiente código al archivo index.js:
Archivo index.js
----------------------------------------------------
// Importar Express
let express = require ('express')
// Iniciar aplicación
let app = express ();
// Asignar puerto
var port = process.env.PORT || 8080;
// Mensaje de bienvenida
app.get ('/', (req, res) => res.send ('Bienvenido a Express'));
// Inicia la aplicación en el puerto especificado
app.listen (port, function () {
console.log ("Ejecutando FirstRest en Puerto: " + port);
})
Ejecutamos el servidor
Ejecute el proyecto con el siguiente comando en el directorio del proyecto.
Terminal ---------------- C:\Users\Your Name\FirstRest > node index
Abra el proyecto en http://localhost:8080 en su navegador y obtendrá la siguiente pantalla.
Necesitamos crear el modelo, el controlador y las rutas para crear nuestra primera API en node.js.
Añadimos el archivo routes.js a la raíz del proyecto y agregamos el siguiente código dentro del archivo:
Archivo routes.js
----------------------------
//initialize express router
let router = require('express').Router();
//set default API response
router.get('/', function(req, res) {
res.json({
status: 'API Works',
message: 'Welcome to FirstRest API'
});
});
//Export API routes
module.exports = router;
Ahora instalaremos mongoose:
Terminal ---------------- C:\Users\Your Name\FirstRest > npm install . . . C:\Users\Your Name\FirstRest > npm install mongoose
Ahora se modificará el archivo index.js con el siguiente código:
Archivo index.js
-----------------------------------
// Import express
let express = require('express');
// Import Body parser
let bodyParser = require('body-parser');
// Import Mongoose
let mongoose = require('mongoose');
// Initialise the app
let app = express();
// Import routes
let apiRoutes = require("./routes");
// Configure bodyparser to handle post requests
app.use(bodyParser.urlencoded({
extended: true
}));
app.use(bodyParser.json());
// Connect to Mongoose and set connection variable
mongoose.connect('mongodb://localhost/resthub', { useNewUrlParser: true});
var db = mongoose.connection;
// Added check for DB connection
if(!db)
console.log("Error connecting db")
else
console.log("Db connected successfully")
// Setup server port
var port = process.env.PORT || 8080;
// Send message for default URL
app.get('/', (req, res) => res.send('Hello World with Express'));
// Use Api routes in the App
app.use('/api', apiRoutes);
// Launch app to listen to specified port
app.listen(port, function () {
console.log("Running RestHub on port " + port);
});
Necesitamos detener el servidor una vez y comenzar de nuevo para observar el cambio que hemos realizado. Entonces, primero ejecute Ctrl+C o Cmd+C. Luego, inicie el servidor con node index. Para obtener los cambios que habíamos realizado anteriormente, tenemos que abrir el navegador con http://localhost:8080/api. Ahora puede ver la siguiente pantalla como salida:
Hasta ahora, el escenario de nuestro proyecto es ejecutar el servidor express cada vez que hacemos cambios en nuestro proyecto. Esto es realmente disgustante cuando estamos trabajando en el desarrollo. Entonces, tengo una solución para evitar este tipo de problema instalando nodemon. Esto permitirá que el servidor express vea los cambios y lo reinicie solo. Vea cómo lo vamos a instalar a continuación.
Terminal ------------------- //On Windows C:\Users\Your Name\FirstRest > npm install -g nodemon // On Mac/Linux $ sudo npm install -g nodemon
Ahora para comenzar con nodemon, ejecutemos nuestro proyecto con nodemon usando el siguiente comando.
Terminal -------------------- C:\Users\Your Name\FirstRest > nodemon index
Ahora puede ver que el servidor express se reinicia automáticamente cuando detecta algún cambio en el archivo del proyecto. Gracias a esto nuestro desarrollo sería más rápido.
Paso7. Configurando MongoDBComo estamos usando MongoDB como nuestra base de datos, necesitamos tener mongodb en funcionamiento en nuestra máquina. Para iniciar el servicio de MongoDB en su cmd, debe ingresar el siguiente comando. Mantenga esta ventana abierta para usar nuestra base de datos.
Terminal ------------------- C:\Users\Your Name > mongoPaso8. Instalando Mongoose y Body-Parser
Necesitamos instalar Mongoose y Body-Parser.
Ahora instale ambos usando los siguientes comandos.
Terminal ----------------- C:\Users\Your Name\FirstRest > npm install mongoose --save
Terminal ----------------- C:\Users\Your Name\FirstRest > npm install body-parser --save
Ahora es tiempo de trabajar con nuestro Modelo, Rutas y Controlador. Vamos a implementar algunos campos para bio. Agregaremos bio a la base de datos para poder gestionar sus campos:
Ahora necesitaremos los siguientes endpoints para ejecutar nuestra API.
Ahora vamos a agregar modelo y controlador para realizar CRUD de Bio.
Paso9. Creando el modeloAgregue el archivo llamado bioModel.js en el proyecto y agregue las siguientes líneas de código:
Archivo bioModel.js
---------------------------------
var mongoose = require('mongoose');
//schema
var bioSchema = mongoose.Schema({
name: {
type: String,
required: true
},
email: {
type: String,
required: true
},
phone: {
type: String,
required: true
},
address: {
type: String,
required: true
},
created_at: {
type: Date,
default: Date.now
}
});
// Export Bio Model
var Bio = module.exports = mongoose.model('bio', bioSchema);
module.exports.get = function (callback, limit) {
Bio.find(callback).limit(limit);
}
Paso10. Creando las rutas
Ahora actualizamos el archivo routes.js que definimos antes con las siguientes líneas de código para incluir diferentes endpoints que mencionamos anteriormente.
Archivo routes.js
---------------------------------
//initialize express router
let router = require('express').Router();
//set default API response
router.get('/', function(req, res) {
res.json({
status: 'API Works',
message: 'Welcome to FirstRest API'
});
});
//Import Bio Controller
var bioController = require('./bioController');
// Bio routes
router.route('/bio')
.get(bioController.index)
.post(bioController.add);
router.route('/bio/:bio_id')
.get(bioController.view)
.patch(bioController.update)
.put(bioController.update)
.delete(bioController.delete);
//Export API routes
module.exports = router;
Paso11. Creando un controlador
Creamos un archivo con el nombre bioController.js en la raíz del proyecto. Agregamos las siguientes líneas de código para manejar diferentes tipos de solicitud y proporcionar respuesta de acuerdo con la solicitud que recibimos.
Archivo bioController.js
---------------------------------------
//Import Bio Model
Bio = require('./bioModel');
//For index
exports.index = function (req, res) {
Bio.get(function (err, bio) {
if (err)
res.json({
status: "error",
message: err
});
res.json({
status: "success",
message: "Got Bio Successfully!",
data: bio
});
});
};
//For creating new bio
exports.add = function (req, res) {
var bio = new Bio();
bio.name = req.body.name? req.body.name: bio.name;
bio.email = req.body.email;
bio.phone = req.body.phone;
bio.address = req.body.address;
//Save and check error
bio.save(function (err) {
if (err)
res.json(err);
res.json({
message: "New Bio Added!",
data: bio
});
});
};
// View Bio
exports.view = function (req, res) {
Bio.findById(req.params.bio_id, function (err, bio) {
if (err)
res.send(err);
res.json({
message: 'Bio Details',
data: bio
});
});
};
// Update Bio
exports.update = function (req, res) {
Bio.findById(req.params.bio_id, function (err, bio) {
if (err)
res.send(err);
bio.name = req.body.name ? req.body.name : bio.name;
bio.email = req.body.email;
bio.phone = req.body.phone;
bio.address = req.body.address;
//save and check errors
bio.save(function (err) {
if (err)
res.json(err)
res.json({
message: "Bio Updated Successfully",
data: bio
});
});
});
};
// Delete Bio
exports.delete = function (req, res) {
Bio.deleteOne({
_id: req.params.bio_id
}, function (err, contact) {
if (err)
res.send(err)
res.json({
status: "success",
message: 'Bio Deleted'
})
})
}
Paso12. Probando en Postman
Descarga la aplicación Postman para probar cada uno de los endpoints de nuestra aplicación. Una vez instalado podemos utilizar nuestra Api. En primer lugar, veamos qué tenemos en bio. Ingrese http://localhost:8080/api/bio y envíe la solicitud GET como se muestra a continuación y obtendrá la respuesta con la lista vacía.
Agreguemos datos a bio. Debe seleccionar POST como tipo de solicitud, seleccionar la opción body y después x-www-form-urlencoded. Luego agregue los siguientes campos y sus valores como se muestra en la siguiente ilustración.
Después de ejecutar el envío de la solicitud, hemos creado una nueva biografía en nuestra base de datos. Agregamos de 2 a 3 bios más a nuestra base de datos como antes.
Nuevamente recuperamos los datos que tenemos en bio con la solicitud GET de la siguiente manera.
Para recuperar la biografía única, pasamos el ID en la URL con la solicitud GET como se indica a continuación.
Ahora estamos actualizando el valor de una de las bio con solicitud PUT de la siguiente manera.
Del mismo modo, podemos eliminar la biografía usando la identificación como se indica a continuación con la solicitud DELETE.
Después de eliminar una de las bio, recuperemos las bio restantes de nuestra base de datos como se indica a continuación.
Con esto finalizamos nuestro CRUD simple de una biografía (bio) con la ayuda de Node.js, ExpressJS y MongoDB.
Descarga el siguiente documento y completa la información proporcionando ejemplos de los paradigmas de eCommerce. Da clic aquí para descargar la presentación.
Primero necesitas crear un directorio para tu proyecto llamado login_passport, abrir la terminal desde ese directorio y escribir los siguientes comandos:
Terminal ------------------ C:\Users\Your Name > mkdir login_passport C:\Users\Your Name > cd login_passport C:\Users\Your Name\login_passport > npm init C:\Users\Your Name\login_passport > npm installPaso2. Instalando paquetes
Después, dentro del directorio deberás instalar los siguientes paquetes necesarios para el login:
Terminal ------------------ C:\Users\Your Name\login_passport > npm i express express-session cookie-parser connect-flash ejs bcrypt-nodejs body-parser mongoose morgan passport passport-localPaso3. Inicia MongoDB
Ahora abre una nueva terminal y escribe el siguiente comando dejando la ventana abierta:
C:\Users\Your Name\login_passport > mongodPaso4. Estructura del proyecto
Ahora crea algunos de los siguientes directorios dentro del proyecto con sus respectivos archivos:
Dentro de la carpeta node_modules se debe verificar que los siguientes paquetes esten instalados, verificando que la se encuentre una carpeta con su respectivo nombre:
Archivo app/models/user.js
user.js
---------------------
const mongoose = require('mongoose');
const bcrypt = require('bcrypt-nodejs');
const userSchema = new mongoose.Schema({
local: {
email: String,
password: String
},
facebook: {
id: String,
token: String,
email: String,
password: String
},
twitter: {
id: String,
token: String,
email: String,
password: String
},
google: {
id: String,
token: String,
email: String,
password: String
}
});
// generating a hash
userSchema.methods.generateHash = function (password) {
return bcrypt.hashSync(password, bcrypt.genSaltSync(8), null);
};
// checking if password is valid
userSchema.methods.validPassword = function (password) {
return bcrypt.compareSync(password, this.local.password);
};
// create the model for user and expose it to our app
module.exports = mongoose.model('User', userSchema);
Archivo app/routes.js
routes.js
------------------
module.exports = (app, passport) => {
// index routes
app.get('/', (req, res) => {
res.render('index');
});
//login view
app.get('/login', (req, res) => {
res.render('login.ejs', {
message: req.flash('loginMessage')
});
});
app.post('/login', passport.authenticate('local-login', {
successRedirect: '/profile',
failureRedirect: '/login',
failureFlash: true
}));
// signup view
app.get('/signup', (req, res) => {
res.render('signup', {
message: req.flash('signupMessage')
});
});
app.post('/signup', passport.authenticate('local-signup', {
successRedirect: '/profile',
failureRedirect: '/signup',
failureFlash: true // allow flash messages
}));
//profile view
app.get('/profile', isLoggedIn, (req, res) => {
res.render('profile', {
user: req.user
});
});
// logout
app.get('/logout', (req, res) => {
req.logout();
res.redirect('/');
});
};
function isLoggedIn (req, res, next) {
if (req.isAuthenticated()) {
return next();
}
res.redirect('/');
}
Paso7. Archivos del directorio config:
config/database.js
database.js
----------------
module.exports = {
'url': 'mongodb://localhost/login-node'
};
config/passport.js
passport.js
----------------
const LocalStrategy = require('passport-local').Strategy;
const User = require('../app/models/user');
module.exports = function (passport) {
// required for persistent login sessions
// passport needs ability to serialize and unserialize users out of session
passport.serializeUser(function (user, done) {
done(null, user.id);
});
// used to deserialize user
passport.deserializeUser(function (id, done) {
User.findById(id, function (err, user) {
done(err, user);
});
});
// Signup
passport.use('local-signup', new LocalStrategy({
// by default, local strategy uses username and password, we will override with email
usernameField: 'email',
passwordField: 'password',
passReqToCallback : true // allows us to pass back the entire request to the callback
},
function (req, email, password, done) {
User.findOne({'local.email': email}, function (err, user) {
if (err) {
return done(err);
}
if (user) {
return done(null, false, req.flash('signupMessage', 'the email is already taken'));
} else {
var newUser = new User();
newUser.local.email = email;
newUser.local.password = newUser.generateHash(password);
newUser.save(function (err) {
if (err) { throw err; }
return done(null, newUser);
});
}
});
}));
// login
// we are using named strategies since we have one for login and one for signup
// by default, if there was no name, it would just be called 'local
passport.use('local-login', new LocalStrategy({
usernameField: 'email',
passwordField: 'password',
passReqToCallback: true
},
function (req, email, password, done) {
User.findOne({'local.email': email}, function (err, user) {
if (err) { return done(err); }
if (!user) {
return done(null, false, req.flash('loginMessage', 'No User found'))
}
if (!user.validPassword(password)) {
return done(null, false, req.flash('loginMessage', 'Wrong. password'));
}
return done(null, user);
});
}));
}
Paso8. Directorio public
public/css/main.css
main.css
-----------------
.home {
background: black; /* fallback for old browsers */
background: -webkit-linear-gradient(to right, blue, black); /* Chrome 10-25, Safari 5.1-6 */
background: linear-gradient(to right, blue, black); /* W3C, IE 10+/ Edge, Firefox 16+, Chrome 26+, Opera 12+, Safari 7+ */
}
.login {
background: black; /* fallback for old browsers */
background: -webkit-linear-gradient(to right, blue, black); /* Chrome 10-25, Safari 5.1-6 */
background: linear-gradient(to right, blue, black); /* W3C, IE 10+/ Edge, Firefox 16+, Chrome 26+, Opera 12+, Safari 7+ */
}
.signup {
background: black; /* fallback for old browsers */
background: -webkit-linear-gradient(to right, blue, black); /* Chrome 10-25, Safari 5.1-6 */
background: linear-gradient(to right, blue, black); /* W3C, IE 10+/ Edge, Firefox 16+, Chrome 26+, Opera 12+, Safari 7+ */
}
Paso9. Directorio views
views/partials/foot.ejs
foot.ejs ---------------- < script src="https://code.jquery.com/jquery-3.5.1.slim.min.js" integrity="sha384-DfXdz2htPH0lsSSs5nCTpuj/zy4C+OGpamoFVy38MVBnE+IbbVYUew+OrCXaRkfj" crossorigin="anonymous" >< /script > < script src="https://cdn.jsdelivr.net/npm/popper.js@1.16.1/dist/umd/popper.min.js" integrity="sha384-9/reFTGAW83EW2RDu2S0VKaIzap3H66lZH81PoYlFhbGU+6BZp6G7niu735Sk7lN" crossorigin="anonymous" >< /script > < script src="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/js/bootstrap.min.js" integrity="sha384-B4gt1jrGC7Jh4AgTPSdUtOBvfO8shuf57BaghqFfPlYxofvL8/KUEfYiJOMMV+rV" crossorigin="anonymous" >< /script >
views/partials/head.ejs
head.ejs --------------- < meta charset="UTF-8" > < link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0-beta.2/css/bootstrap.min.css" integrity="sha384-PsH8R72JQ3SOdhVi3uxftmaW6Vc51MKb0q5P2rRUpPvrszuE4W1povHYgTpBfshb" crossorigin="anonymous" > < link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css" integrity="sha384-JcKb8q3iqJ61gNV9KGb8thSsNjpSL0n8PARn9HuZOnIxN0hoP+VmmDGMN5t9UJ0Z" crossorigin="anonymous" > < link rel="stylesheet" href="/css/main.css" >
views/partials/header.ejs
header.js ------------------ < nav class="navbar navbar-expand-lg navbar-dark bg-dark" > < a class="navbar-brand" href="#" >Loginiser< /a > < button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarSupportedContent" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation" > < span class="navbar-toggler-icon" >< /span > < /button > < div class="collapse navbar-collapse" id="navbarSupportedContent" > < ul class="navbar-nav mr-auto" > < /ul > < form class="form-inline my-2 my-lg-0" > < a href="/login" class="btn btn-dark" > < span class="fa fa-user" >< /span > Login < /a > < a href="/signup" class="btn btn-dark" > < span class="fa fa-user" >< /span > Signup < /a > < /form > < /div > < /nav >
views/index.ejs
< !DOCTYPE html >
< html lang="en" >
< head >
< title >Authentication with Node< /title >
< %- include("./partials/head") % >
< /head >
< body class="home" >
< %- include("./partials/header") % >
< %- include("./partials/foot") % >
< /body >
< /html >
views/login.ejs
< !DOCTYPE html >
< html >
< head >
< meta charset="utf-8" >
< title >Login< /title >
< %- include("./partials/head") % >
< /head >
< body class="login" >
< %- include("./partials/header") % >
< div class="container" >
< div class="col-sm-6 mx-auto" >
< div class="card mt-5" >
< div class="card-body" >
< !-- messages -- >
< h1 class="text-center" >
< span class="fa fa-sign-in" >< /span > Login
< /h1 >
< % if (message.length > 0) { % >
< div class="alert alert-danger" >
< %= message % >
< /div >
<% } % >
< form action="/login" method="post" >
< div class="form-group" >
< label for="email" >Email< /label >
< input type="email" name="email" class="form-control" >
< /div >
< div class="form-group" >
< label for="password" >Password< /label >
< input type="password" name="password" class="form-control" >
< /div >
< input type="submit" class="btn btn-dark btn-lg" >
< /form >
< hr >
< div class="text-center" >
< p >Need an account? < a href="/signup" >Signup< /a >< /p >
< p >Or go < a href="/" >home< /a >.< /p >
< /div >
< /div >
< /div >
< /div >
< /div >
< /body >
< /html >
views/profile.ejs
< !DOCTYPE html >
< html >
< head >
< meta charset="utf-8" >
< title >Profile Page< /title >
< %- include("./partials/head") % >
< /head >
< body >
< nav class="navbar navbar-expand-lg navbar-dark bg-dark" >
< a class="navbar-brand" href="#" >Loginiser< /a >
< button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarSupportedContent" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation" >
< span class="navbar-toggler-icon" >< /span >
< /button >
< div class="collapse navbar-collapse" id="navbarSupportedContent" >
< ul class="navbar-nav mr-auto" >
< li class="nav-item active" >
< a class="nav-link" href="#" >Inicio < span class="sr-only" >(current)< /span >< /a >
< /li >
< /ul >
< form class="form-inline my-2 my-lg-0" >
< a href="/logout" class="btn btn-danger btn-sm" >
Logout
< /a >
< /form >
< /div >
< /nav >
< div class="container" >
< header class="text-center" >
< h1 >Profile Page< /h1 >
< /header >
< hr >
< div class="container" >
< div class="col-sm-6" >
< div class="card" style="width: 18rem;" >
< img src="https://www.soycobre.com/wp-content/uploads/2020/05/cubre-bocas.jpg" class="card-img-top" alt="..." >
< div class="card-body" >
< h5 class="card-title" >Card title< /h5 >
< p >
< strong >id< /strong > : <%= user._id %> < br >
< strong >email< /strong > : <%= user.local.email %> < br >
< strong >password< /strong > : <%= user.local.password %>
< /p >
< a href="/logout" class="btn btn-danger" >Logout< /a >
< /div >
< /div >
< /div >
< /div >
< /div >
<%- include("./partials/head") %>
< /body >
< /html >
views/signup.ejs
< !DOCTYPE html >
< html >
< head >
< meta charset="utf-8" >
< title >Login< /title >
<%- include("./partials/head") %>
< /head >
< body class="signup" >
<%- include("./partials/header") %>
< div class="container" >
< div class="col-sm-6 mx-auto" >
< div class="card mt-5" >
< div class="card-body" >
< !-- messages -- >
< h1 class="text-center" >
< span class="fa fa-sign-in" >< /span> Signup
< /h1 >
<% if (message.length > 0) { %>
< div class="alert alert-danger" >
<%= message %>
< /div >
<% } %>
< !-- form -- >
< form action="/signup" method="post" >
< div class="form-group" >
< label for="email" >Email< /label >
< input type="email" name="email" class="form-control" >
< /div >
< div class="form-group" >
< label for="password" >Password< /label >
< input type="password" name="password" class="form-control" >
< /div >
< input type="submit" class="btn btn-dark btn-lg" >
< /form >
< hr >
< div class="text-center" >
< p >Already have an account? < a href="/login" >Login< /a >< /p >
< p >Or go < a href="/" >home< /a >.< /p >
< /div >
< /div >
< /div >
< /div >
< /div >
< /body >
< /html >
Paso10. Archivo package-look.json
Verifica que tengas creado el archivo package-look.json y que ahí se encuentren definidos los paquetes instalados.
Paso11. Archivo server.jsserver.js
server.js
------------------
const express = require('express');
const app = express();
const path = require('path');
const mongoose = require('mongoose');
const passport = require('passport');
const flash = require('connect-flash');
const morgan = require('morgan');
const cookieParser = require('cookie-parser');
const bodyParser = require('body-parser');
const session = require('express-session');
const { url } = require('./config/database.js');
mongoose.connect(url, {
useMongoClient: true
});
require('./config/passport')(passport);
// settings
app.set('port', process.env.PORT || 3000);
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'ejs');
// middlewares
app.use(morgan('dev'));
app.use(cookieParser());
app.use(bodyParser.urlencoded({extended: false}));
// required for passport
app.use(session({
secret: 'faztwebtutorialexample',
resave: false,
saveUninitialized: false
}));
app.use(passport.initialize());
app.use(passport.session());
app.use(flash());
// routes
require('./app/routes.js')(app, passport);
// static files
app.use(express.static(path.join(__dirname, 'public')));
// start the server
app.listen(app.get('port'), () => {
console.log('server on port ', app.get('port'));
});
Paso12. Iniciando el servidor
Inicia el servidor con el siguiente comando:
Terminal ------------------ C:\Users\Your Name\login_passport > node server.js
Abre el navegador y escribe la siguiente url:
localhost:3000
