Conceptos Básicos

Nodejs

Node.js es una librería y entorno de ejecución de E/S dirigida por eventos y por lo
tanto asíncrona que se ejecuta sobre el intérprete de JavaScript creado por Google V8. Lo
cierto es que está muy de moda aunque no es algo nuevo puesto que existen librerías como
Twisted que hacen exactamente lo mismo pero si es cierto que es la primera basada en
JavaScript y que tiene un gran rendimiento.

Cuál es el problema con los programas de servidor actuales?

Hagamos cuentas. En lenguajes como Java™ y PHP, cada conexión genera un nuevo hilo que
potencialmente viene acompañado de 2 MB de memoria. En un sistema que tiene 8 GB de
RAM, esto da un número máximo teórico de conexiones concurrentes de cerca de 4.000
usuarios. A medida que crece su base de clientes, si usted desea que su aplicación soporte más
usuarios, necesitará agregar más y más servidores. Por todas estas razones, el cuello de
botella en toda la arquitectura de aplicación Web (incluyendo el rendimiento del tráfico, la
velocidad de procesador y la velocidad de memoria) era el número máximo de conexiones
concurrentes que podía manejar un servidor.

Node resuelve este problema cambiando la forma en que se realiza una conexión con el
servidor. En lugar de generar un nuevo hilo de OS para cada conexión (y de asignarle la
memoria acompañante), cada conexión dispara una ejecución de evento dentro del proceso
del motor de Node. Node también afirma que nunca se quedará en punto muerto, porque no
se permiten bloqueos y porque no se bloquea directamente para llamados E/S.

NPM

simplemente npm es un gestor de paquetes, el cual hará más fáciles nuestras vidas al
momento de trabajar con Node, ya que gracias a él podremos tener cualquier librería
disponible con solo una línea de código, npm nos ayudará a administrar nuestros módulos,
distribuir paquetes y agregar dependencias de una manera sencilla.

GULP

Gulp es una herramienta, en forma de script en NodeJS, que te ayuda a automatizar tareas
comunes en el desarrollo de una aplicación, como pueden ser: mover archivos de una carpeta
a otra, eliminarlos, minificar código, sincronizar el navegador cuando modificas tu código,
validar sintáxis y un largo etcétera.

MongoDB

MongoDB es una base de datos orientada a documentos. Esto quiere decir que en lugar de
guardar los datos en registros, guarda los datos en documentos. Estos documentos son
almacenados en BSON, que es una representación binaria de JSON.

Una de las diferencias más importantes con respecto a las bases de datos relacionales, es
que no es necesario seguir un esquema. Los documentos de una misma colección - concepto
similar a una tabla de una base de datos relacional -, pueden tener esquemas diferentes.
Socket

es una librería en JavaScript para Node.js que permite una comunicación bidireccional en
tiempo real entre cliente y servidor. Para ello se basa principalmente en Websocket pero
también puede usar otras alternativas como sockets de Adobe Flash, JSONP polling o long
polling en AJAX, seleccionando la mejor alternativa para el cliente justo en tiempo de
ejecución.

Heroku

Heroku es uno de los PaaS más utilizados en la actualidad en entornos empresariales por su
fuerte enfoque en resolver el despliegue de una aplicación. Ademas te permite manejar los
servidores y sus configuraciones, escalamiento y la administración. A Heroku solo le dices qué
lenguaje de backend estás utilizando o qué base de datos vas a utilizar y te preocupas
únicamente por el desarrollo de tu aplicación.

Javascript EcmaScript 6
Ecmascript es el estándar que define cómo debe de ser el lenguaje Javascript

Javascript es interpretado y procesado por multitud de plataformas, entre las que se

encuentran los navegadores web, así como NodeJS y otros ámbitos más específicos como el
desarrollo de aplicaciones para Windows y otros sistemas operativos. Todos los responsables
de cada una de esas tecnologías se encargan de interpretar el lenguaje tal como dice el
estándar ECMAScript.

Ámbitos de Variable (scope)

Var: Se podrá usar cuando se trata de asignar un ámbito de toda una función, o ámbito global

Let: restringe su existencia al ámbito donde ha sido declarada (cualquier ámbito expresado con
unas llaves)

Const: Esto nos crea una variable donde su valor es inalterable a lo largo del código

Escope es el ámbito donde declaramos nuestras variables, por lo tanto, el scope es la lista de
variables a las cuales tenemos acceso.

Las variables declaradas dentro de una función se vuelven locales, por lo que solo podemos
acceder a ellas dentro de la función en sí, veamos un ejemplo:

/ Ámbito global
var x = "X";

function test() {
// Ámbito local
var y = "Y";

// Como (x) está definida en un ámbito global,

// podemos acceder a ella desde cualquier lado.
console.log(x); // <- X
}
test();

// Pero como (y) está definida en un ámbito local (dentro

la función test)
// no podemos acceder a ella desde fuera.
console.log(y) // <- ReferenceError: y is not defined

Las variables declaradas usando let o const también se vuelven locales, pero la gran diferencia
es que solo podemos acceder a ellas dentro del bloque donde fueron declaradas, pero no en
todo el ámbito local, veamos un ejemplo:

function test() {
// Ámbito local
if(true) {
// Bloque condicional
var x = "X"; // var tiene un alcance de función
const y = "Y"; // const tiene un alcance de bloque
let z = "Z"; // let tiene un alcance de bloque

console.log(x); // <- X
console.log(y); // <- Y
console.log(z); // <- Z
}

// Como (x) tiene un alcance de función, se puede acceder

// a ella en cualquier parte de la función.
console.log(x); // <- X

// Pero como (y) y (z) tienen un alcance de bloque, solo

// se puede acceder a ellas en el bloque donde fueron
declaradas.
console.log(y); // <- ReferenceError: y is not defined
console.log(z); // <- ReferenceError: z is not defined
}
test();

Características más resaltantes en el uso de Let

-No podemos intentar acceder a la variable antes del momento de su declaración

-No podemos re declarar la misma variable

Recomendación es trabajar con let y solo usar var en caso necesiten un alcance fuera del
bloque.

Funciones flechas (Arrow)

son funciones definidas usando una flecha =>, pero estas se comportan de una manera
diferente a las funciones tradicionales en varios aspectos.
En el siguiente ejemplo, la funcion flecha toma un único argumento y simplemente lo
devuelve.

let reflect = value => value;

// Que sería lo mismo que hacer esto:

var reflect = function (value) {
return value;
};

Varios Argumentos

let sum = (n1, n2) => n1 + n2;

// Que sería lo mismo que hacer esto:

var sum = function (n1, n2) {
return n1 + n2;
};

Forma tradicional

let sum = (n1, n2) => {

return n1 + n2;
};

// Que sería lo mismo que hacer esto:

var sum = function (n1, n2) {
return n1 + n2;
};

Si deseamos retornar un objeto ese caso tenemos que encapsularlo entre paréntesis. Por
ejemplo:

var getTempItem = id => ({id: id, name: "Temp"});

// Que sería lo mismo que hacer esto:

var getTempItem = function (id) {
return {
id: id,
name: "Temp"
};
};

Clases

las clases se declaran de manera similar a otros lenguajes, usando la palabra "class", seguida
del nombre de la clase que estamos creando.
class Coordenada {
}
Nota: Los nombres de las clases, igual que las variables o el lenguaje Javascript en general, son
sensibles a mayúsculas y minúsculas. Podríamos llamarla como se desee, pero por convención
se usa siempre la primera letra en mayúsculas.
El constructor, se encarga de resumir las tareas de inicialización de los objetos

class Coordenada {
constructor(x, y) {
this.x = x;
this.y = y;
}
}

Nota: No puede haber más de un método llamado constructor en una clase de Javascript. Si
por despiste colocamos más de uno recibiremos un mensaje de error "A class may only have
one constructor"

Como en otros lenguajes, usamos la palabra "new" para crear nuevos objetos de una clase,
seguida del nombre de la clase y todos los parámetros que se deban indicar para invocar al
constructor.
var testCoordenada = new Coordenada(8,55);

En el código del ejemplo de la coordenada ya teníamos un método, aunque algo especial, ya

que era el método constructor. El constructor debe tener siempre el nombre "constructor",
pero podríamos crear otros métodos con cualquier otro nombre.
class Coordenada {
constructor(x, y) {
this.x = x;
this.y = y;
}

esIgual(coordenada) {
if (this.x == coordenada.x && this.y == coordenada.y) {
return true;
}
return false;
}
}
var testCoordenada = new Coordenada(8,55);
console.log(testCoordenada.esIgual(new Coordenada(3, 1)))

Las clases siempre deben ser declarados antes de su uso

Es indispensable que se declaren las clases antes de usarlas. A diferencia de las funciones en
Javascript, que se pueden usar antes de haber sido declaradas, las clases deben conocerse
antes de poder instanciar objetos.
var Persona = class {
constructor(nombre) {
this.nombre = nombre;
}
}

Las clases también pueden ser anónimas

Herencia en las clases

Extender clases en ES6

Extender una clase es el mecanismo por el cual una clase se construye en base a otra, es decir,
el mecanismo mediante el cual se construyen clases hijas o clases derivadas. Obviamente, para
extender, lo primero que debemos tener es la clase padre y mediante esta extensión construir
una clase hija.
class Coordenada3D extends Coordenada {

}
En este caso, la clase Coordenada3D es la clase hija y la clase Coordenada es la clase padre. Por
tanto, la clase Coordenada3D hereda todas las propiedades y métodos existentes en la clase
Coordenada.

Invocación al constructor de la clase padre

El mecanismo para invocar a métodos existentes en la implementación del padre es mediante

la palabra "super" y los paréntesis de invocación de métodos.
class Coordenada3D extends Coordenada {
constructor(x, y, z) {
super(x, y);
this.z = z;
}
}

Sobreescritura de métodos

La redefinición o sobreescritura de métodos es una de las tareas habituales al extender clases.

Consiste en reprogramar ciertas operaciones en la clase hija, algo que se traduce en la
reescritura del código de los métodos que teníamos en el padre. Para conseguirlo simplemente
se tiene que volver a declarar el método con el mismo nombre existente en la clase padre.

Como en el caso del constructor, podemos invocar al método original, tal como se había
implementado en la clase padre, mediante super().
class Coordenada3D extends Coordenada {
constructor(x, y, z) {
super(x, y);
this.z = z;
}

esIgual(coordenada3D) {
if(super.esIgual(coordenada3D) && this.z == coordenada3D.z) {
return true;
}
return false;
 }
}

Promesas

El objeto Promise (Promesa) es usado para computaciones asíncronas. Una promesa

representa un valor que puede estar disponible ahora, en el futuro, o nunca.

Una Promesa recuerda el contexto en donde se ejecuta, es decir, sabe con precisión en qué
punto se ha de resolver un valor o lanzar un error. Cuando una promesa entra en ejecución
pasa a tener 2 estados, uno inicial y uno final:

 pending (pendiente)

 fullfilled (resuelta exitosamente)

 rejected (rechazada)

var promise = new Promise(function(resolve, reject) {

// hacer algo que puede ser asíncrono, then…

if (/* todo está bien */) {

resolve("Exito");
}
else {
reject(Error("Algo falló"));
}
});

El constructor de la promesa recibe un argumento: un callback con dos parámetros (resolve y

reject). A continuación, se hace algo con el callback (tal vez un proceso asincrónico) y se llama
a resolve si todo funciona bien o a reject si esto no sucede.
promise.then(function(result) {
console.log(result); // "Todo bien!"
}, function(err) {
console.log(err); // Error: "Hubo un fallo"
});

then() recibe dos argumentos: un callback para cuando se tiene éxito y otro para cuando
sucede lo contrario. Ambos son opcionales; puedes agregar un callback solo para cuando se
tiene éxito o se produce una falla

ejemplos de uso de las promesas.

El constructor new Promise() sólo debe utilizarse para tareas asíncronas

heredadas, como el uso de setTimeout o XMLHttpRequest. Se crea una nueva
promesa con la nueva palabra clave y la promesa proporciona funciones de
resolución y rechazo a la devolución de llamada proporcionada:
var p = new Promise(function(resolve, reject) {

// Hacer tarea asíncrona y then...

 if(/* éxito */) {
resolve('Success!');
}
else {
reject('Fallo!');
}
});

p.then(function() {
/* hacer algo con el resultado */
}).catch(function() {
/* error :( */
})

NodeJS, Web socket y MongoDB

Que es Nodejs:

Node es un intérprete Javascript del lado del servidor que cambia la noción de cómo debería
trabajar un servidor. Su meta es permitir a un programador construir aplicaciones altamente
escalables y escribir código que maneje decenas de miles de conexiones simultáneas en una
sólo una máquina física.

Empecemos

Abre tu editor favorito y crea un archivo llamado main.js. Nosotros queremos escribir "Hola
Mundo" a STDOUT, y aquí está el código necesario para hacer esto:

console.log("Hola Mundo");

Graba el archivo, y ejecútalo a través de Node.js:

node holamundo.js

Los casos de Uso

Mantengámoslo simple, pero realista:

 El Usuario debería ser capaz de ocupar nuestra aplicación con un browser.

 El Usuario debería ver una página de bienvenida cuando solicita http://dominio/inicio,

la cual despliega un formulario de subida.

 Eligiendo un archivo de imagen para subir y enviando el formulario, la imagen debería

ser subida a http://dominio/subir, donde es desplegada una vez que la subida este
finalizada.

La Pila de Aplicaciones

Hagamos un desglose a nuestra aplicación. ¿Qué partes necesitan ser implementadas?

 Queremos servir páginas web, de manera que necesitamos un Servidor HTTP.

 Nuestro servidor necesitará responder directamente peticiones (requests),

dependiendo de qué URL sea pedida en este requerimiento, es que necesitaremos
 algún tipo de enrutador (router) de manera de mapear los peticiones a los handlers
(manejadores) de éstos.

 Para satisfacer a los peticiones que llegaron al servidor y han sido ruteados usando el
enrutador, necesitaremos de hecho handlers (manejadores) de peticiones

 El Enrutador probablemente debería tratar cualquier información POST que llegue y

dársela a los handlers de peticiones en una forma conveniente, luego
necesitaremos manipulación de data de petición

 Nosotros no solo queremos manejar peticiones de URLs, sino que también queremos
desplegar contenido cuando estas URLs sean pedidas, lo que significa que necesitamos
algún tipo de lógica en las vistas a ser utilizada por los handlers de peticiones, de
manera de poder enviar contenido al browser del Usuario.

 Por último, pero no menos importante, el Usuario será capaz de subir imágenes, así
que necesitaremos algún tipo de manipulación de subidasquien se hará cargo de los
detalles.

Node.js, no solo implementamos nuestra aplicación, nosotros también implementamos todo el

servidor HTTP completo. De hecho, nuestra aplicación web y su servidor web son básicamente
lo mismo.

Vamos a Construir un servidor HTTP Básico

Empecemos con el módulo del servidor. Crea el archivo server.js en el directorio raíz de tu
proyecto, y llénalo con el código siguiente:

var http = require("http");

http.createServer(function(request, response) {

response.writeHead(200, {"Content-Type": "text/html"});

response.write("Hola Mundo");

response.end();

}).listen(8888);

Eso es! Acabas de escribir un servidor HTTP activo. Probémoslo ejecutándolo y testeándolo.
Primero ejecuta tu script con Node.js:

node server.js

La primera línea require, requiere al módulo http que viene incluido con Node.js y lo hace
accesible a través de la variable http.

Luego llamamos a una de las funciones que el módulo http ofrece: createServer. Esta función
retorna un objeto, y este objeto tiene un método llamado listen(escucha), y toma un valor
numérico que indica el número de puerto en que nuestro servidor HTTP va a escuchar.
Podemos llegar a lo mismo refactorizando nuestro código así:

var http = require("http");

function onRequest(request, response) {

response.writeHead(200, {"Content-Type": "text/html"});

response.write("Hola Mundo");

response.end();

http.createServer(onRequest).listen(8888);

Bien. Ya tenemos claro como hacer uso de los módulos internos de Node.js. ¿Cómo hacemos
para crear nuestros propios módulos, y Cómo los utilizamos?

Descubrámoslo transformando nuestro script server.js en un módulo real.

Sucede que, no tenemos que transformarlo tanto. Hacer que algún código sea un Módulo,
significa que necesitamos exportar las partes de su funcionalidad que queremos proveer a
otros scripts que requieran nuestro módulo.

Por ahora, la funcionalidad que nuestro servidor HTTP necesita exportar es simple: Permitir a
los scripts que utilicen este módulo arrancar el servidor.

Para hacer esto posible, dotaremos al código de nuestro servidor de una función
llamada inicio, y exportaremos esta función:

var http = require("http");

function iniciar() {

function onRequest(request, response) {

console.log("Petición Recibida.");

response.writeHead(200, {"Content-Type": "text/html"});

response.write("Hola Mundo");

response.end();

http.createServer(onRequest).listen(8888);

console.log("Servidor Iniciado.");

}
exports.iniciar = iniciar;

De este modo, Podemos crear nuestro propio archivo principal index.js, y arrancar nuestro
servidor HTTP allí, aunque el código para el servidor este en nuestro archivo server.js.

Crea un archivo index.js con el siguiente contenido:

var server = require("./server");

server.iniciar();

Como puedes ver, nosotros utilizamos nuestro módulo de servidor tal como
cualquier otro módulo interno: requiriendo el archivo donde está
contenido y asignándolo a una variable, con las funciones que tenga
'exportadas' disponibles para nosotros.

Eso es. Podemos ahora arrancar nuestra aplicación por medio de nuestro
script principal, y va a hacer exactamente lo mismo:

node index.js

Ahora, abre tu browser y apúntalo a http://localhost:8888/. Esto debería desplegar una página
web que diga "Hola Mundo".

MongoDB

MongoDB es una base de datos orientada a documentos. Los documentos los guarda en
BSON, que es una forma de representar de forma binaria objetos JSON.

Instalacion de MOngoDB

Obtener el instalador para Windows

https://www.mongodb.com/download-center#community

1. Crear las carpeta de almacenamiento y configuracion de MongoDB.

  Dar permisos escritura y lectura a estas carpetas.

C:\data
C:\data\db

4. (Opcional) Crear las carpeta de almacenamiento en una ruta segura

ejemplo:

D:\mongodb\data\db

5. Iniciar el servidor del servicio de MongoDB: mongod.

C:\mongodb\bin\mongod.exe

6. (Opcional) Si se usa una ruta personalizada se debe pasar un parámetro

con la ruta al iniciar el servidor de mongo.

C:\mongodb\bin\mongod.exe --dbpath D:\mongodb\data\db

7. Iniciar el shell de mongo.

C:\mongodb\bin\mongo.exe

Configurar MongoDB Enterprise

como un servicio en windows
crear el archivo
at C:\Program Files\MongoDB\Server\3.4\mongod.cfg
que contenga

systemLog:
destination: file
path: c:\data\log\mongod.log
storage:
dbPath: c:\data\db
crear folder
C:\data/log

iniciar consola como administrator

"C:\Program Files\MongoDB\Server\3.4\bin\mongod.exe" --config "C:\Program
Files\MongoDB\Server\3.4\mongod.cfg" --install

iniciar servicio
net start MongoDB

detener servicio
net stop MongoDB
Normalmente en las bases de datos, hablamos de operaciones CRUD (Create,
Read, Insert y Delete)

En Mongo estos son los nombres asociados a

Operación Nombre en MongoDB

Create Insert
Read Find
Update Update
Delete Remove

vimos las características generales de esta base de datos NoSQL.

Cualquier base de datos que se precie, tiene que permitirnos

realizar las típcias operaciones: inserciones, modificaciones,
eliminaciones y consultas. MongoDB no es diferente, y aunque
tiene algunas peculariades que iremos describiendo, permite
realizar dichas operaciones. Eso sí, nos tenemos que olvidar de
SQL.

En este artículo, voy a explicar como se pueden insertar datos. El

resto de operaciones, las dejamos para futuros artículos.

Lo primero, es lo primero. Insertando

datos
Como ya dijimos MongoDB es una base de datos orientada a
documentos. Los documentos los guarda en BSON, que es una
forma de representar de forma binaria objetos JSON.

Insertar documentos es muy sencillo. Solo hay que conectarse la

consola y escribir el comando db.nombre_coleccion.insert. Como
parámetro pasaremos el objeto JSON que queremos insertar. Por
ejemplo, si queremos insertar en la colección genbetadev:
 db.genbetadev.insert(

name:"Tyrion",

hobbyes:["books","girls","wine"],

friends:

{name:"Bronn", ocuppation:"sellsword"},

{name:"Shae", ocuppation:"handmaiden"}

Insertando documentos de forma

masiva
Si queremos insertar una gran cantidad de ellos, nos conviene
usar el comando insert, pero pasando como parámetro un array
de documentos. De esta manera MongoDB optimizará las
inserciones, haciendo que sean mucho más rápidas.

db.genbetadev.insert(

{name:"Jaime"},

{name:"Rob"},

{name:"Sansa"}

])
ACTUALIZANDO

Para actualizar ese documento con una sentencia update, la

consulta sería similar a esta:

db.genbeta.update(

{"_id" : ObjectId("5305eae128222ca13a01b039")},

{"name" : "Heinsenberg"}

para actualizar o añadir un campo a un documento existente,

debemos utilizar el comando $set.

db.products.update({
_id: ObjectId("51e6681a2b7e6dab80c1ebd6")},
{
$set:{cantidad:52,
descripcion:"Disco duro de alta densidad"
}
})

Si queremos eliminar un campo de un documento, deberemos hacer

una consulta similar, pero utilizando $unset.

db.products.update(
{ _id: ObjectId("51e6681a2b7e6dab80c1ebd6")},
{
$unset:{descripcion:1}
})
Si la colección no existe, MongoDB la creará automáticamente. Si
ahora hacemos un find, veremos que el documento está insertado
en la nueva colección.

db.genbetadev.find()

Para mostrar por pantalla todos los documentos de una colección:

> db.coord.find()

Se puede mejorar diciendo al shell que lo imprima bien indentado:

db.cuentas.find().pretty()

Otra forma más elegante de mostrar la información es mediante arrays, que

además pueden sernos útiles para consultas complejas:

> db.cuentas.find().toArray()
que transfiere la colección a un array javascript y lo muestra de forma
ordenada.
si se quiere hacer un array con solo los 2 primeros elementos se puede limitar:
db.cuentas.find().limit(2).toArray()
También se pueden "saltar" saltar unos cuantos resultados. Digamos que
queremos los documentos que ocupan las posiciones 2 y 3, ambas incluídas:

db.cuentas.find().limit(2).skip(1).pretty()

Si solo queremos el primer elemento, podemos usar findOne:

db.cuentas.findOne()

find en detalle

Es hora de ver en más detalle el método find. Su forma general tiene dos
parámetros:

find(consulta, proyección)

Para eliminar documentos en MongoDB podemos hacerlo de

manera directa sobre el documento deseado o lo que sería el
equivalente a la instrucción “delete” en SQL, veamos:

db.empleados.remove({“cedula” : “123456”});

Con lo que lograremos eliminar el empleado o los empleados que

cuenten con la cedula: 123456, hay que tener cierto cuidado con
este comando en entornos de producción, ya que no tiene
marcha a tras y los datos son eliminados de manera permanente.

ELIMINANDO TODA UNA COLECCIÓN

Muchas veces no solo deseamos eliminar documentos si no
deshacernos de toda una colección, acción que podemos realizar
de la siguiente forma:

db.empleados.drop();
Si desea eliminar el primer registro encontrado se puede establecer
justOne 1, de la siguiente manera:

>db.COLLECTION_NAME.remove(DELETION_CRITERIA,1)

Si desea eliminar todos los datos, puede utilizar los métodos siguientes
(similar al SQL convencional truncar el comando):

>db.col.remove({})
>db.col.find()

Eliminar bases de datos en MongoDB

Para eliminar bases de datos en MongoDB se usa el método “dropDatabase” del
documento “db” (no a nivel de colección). Este método se ejecuta sin parámetros
para borra la base de datos, al completo, que se esté usando.

Como ejemplo, se van a crear varias colecciones (insertando un documento) en

una base de datos cualquiera para después ser borradas:
?

> use market

switched to db market

> show collections

db.coll1.insert({_id:"Happy"})
> db.coll2.insert({_id:"Happy Minds!"})
> db.coll3.insert({_id:"Happy Minds! Software"})
>
> show collections
coll1
coll2
coll3
system.indexes

> db.dropDatabase()
{ "dropped" : "market", "ok" : 1 }
> show collections
>
Una base de datos borrada no afecta al uso posterior que puedan hacer las
aplicaciones clientes ya que, si después de borrada se insertan documentos
volvería a estar operativa salvo que sin los datos anteriores que fueron eliminados.

Seguridad
Este tipo de actualización en MongoDB difiere totalmente de las actualizaciones en
SQL, ya que en este caso, por defecto, se actualizan todos los registros que
coincidan con el criterio de busqueda (where) y, por el contrario, en MongoDB se
actualiza sólo un documento por defecto. Recalco en este punto la importancia de
que el valor por defecto sea false para evitar actualizaciones masivas erróneas
derivadas de un descuido.

MongoDB no tiene una funcionalidad de autoincremento lista para

usar, como las bases de datos SQL. De forma predeterminada, usa
el Id. De Objeto de12 bytes para el campo _id como la clave
primaria para identificar de manera única los documentos. Sin
embargo, puede haber situaciones en las que desee que el campo _id
tenga algún valor autoincrementado distinto del ObjectId.

Dado que esta no es una característica predeterminada en MongoDB,

obtendremos esta funcionalidad programáticamente utilizando
una colección de contadores como lo sugiere la documentación de
MongoDB.
Usando Counter Collection
Considere el siguiente documento de productos . Queremos que el
campo _id sea una secuencia
entera autoincrementada comenzando desde 1,2,3,4 hasta n.

"_id":1,

"product_name": "Apple iPhone",

"category": "mobiles"

Para esto, crea una colección de contadores , que mantendrá un

seguimiento del último valor de secuencia para todos los campos de
secuencia.
>db.createCollection("counters")

Ahora, insertaremos el siguiente documento en la colección de

contadores con productid como su clave:

"_id":"productid",

"sequence_value": 0

El campo sequence_value realiza un seguimiento del último valor de

la secuencia.

Use el siguiente código para insertar este documento de secuencia en

la colección de contadores:
>db.counters.insert({_id:"productid",sequence_value:0})

Crear la función de Javascript

Ahora, crearemos una función getNextSequenceValue que tomará
el nombre de la secuencia como su entrada, incrementará el número
de secuencia en 1 y devolverá el número de secuencia actualizado. En
nuestro caso, el nombre de la secuencia es productid .

>function getNextSequenceValue(sequenceName){
 var sequenceDocument = db.counters.findAndModify({

query:{_id: sequenceName },

update: {$inc:{sequence_value:1}},

new:true

});

return sequenceDocument.sequence_value;

Usando la función de Javascript

Ahora usaremos la función getNextSequenceValue mientras creamos
un documento nuevo y asignamos el valor de la secuencia devuelta
como el campo _id del documento.

Inserte dos documentos de muestra usando el siguiente código:

>db.products.insert({

"_id":getNextSequenceValue("productid"),

"product_name":"Apple iPhone",

"category":"mobiles"

})

>db.products.insert({

"_id":getNextSequenceValue("productid"),

"product_name":"Samsung S3",

"category":"mobiles"

})

Como puede ver, hemos utilizado la función getNextSequenceValue

para establecer el valor para el campo _id.

Para verificar la funcionalidad, busquemos los documentos usando el

comando find -
>db.products.find()

La consulta anterior devolvió los siguientes documentos con el campo

_id autoincrementado -

Para crear backup y restor es mongodump y mongorestore respectivamente

Socket

Heroku