megadb

v3.4.0

Published

3 years ago

base de datos usando JSON

Downloads

816

0High
0Medium
0Low

megastar

database JSON db base de datos

Este package es una actualizacion de mi antiguo package llamado mega-dtbs (https://www.npmjs.com/package/mega-dtbs)
megadb es un manejador de archivos JSON, contiene multiples metodos las cuales te facilitiaran las cosas y podras trabajar de una forma sencilla, persistente y eficaz.

Mejoras

- Ahora podras especificar el directorio donde se guardaran tus base de datos, tambien podras usar sub directorios.
- Se creo una db en memoria (ver el constructor de memoDB)
- Se agrego nuevos metodos y parametros especiales.
- Se actualizo absolutamente todo el codigo para una mejor legibilidad y funcionamiento.
- La base de datos ahora es mas persistente.
- Errores descriptivos.

Importante

Por default se creará una carpeta llamada mega_databases en la carpeta principal de tu proyecto (puedes cambiar el nombre de esta carpeta en el constructor) crearDB. No borres dicha carpeta a menos que quieras borrar absolutamente todas tus base de datos.

Changelog

v3.4.0

Se mejoró la descripcion de los errores.
Se agregó la posibilidad de actualizar la base de datos(con los nuevos datos) cada cierto tiempo para evitar que los archivos JSON se lleguen a reescribir rapidamente, mas informacion: crearDB

v3.3.0

La mayoria de cosas(codigos) fueron reescritas.
Se agrego 2 nuevos metodos (findKey, partition).
El metodo obtener(alias get) ahora retornara undefined cuando no se logre obtener nada.
El metodo filter retornara un objeto vacio {} en lugar de undefined.
El metodo map retornara un array vacio [] en lugar de undefined.
El metodo some ahora retornara unicamente true o false.

v3.0.0

Se agrego 2 nuevos metodos (setIndex, delIndex).
Ahora puedes especificar la carpeta donde se guardaran tus base de datos, mas informacion: crearDB

v2.8.0

Se agrego el metodo some.
Se agrego un alias en los metodos: establecer (set), obtener (get), tiene (has), eliminar (delete), sumar (add), restar (subtract), ordenar (sort)
Se creo el constructor memoDB la cual hará que puedas hacer una db en memoria, ver el apartado de memoDB para mas informacion.

v2.7.0

Se mejoró el metodo sumar y restar, ahora se podrá ingresar numeros en formato string, tambien se mejoró la descripcion de los errores.

V2.6.0

Se removio la comparacion de objetos ya que esto se puede hacer fuera del codigo.

V2.5.0

Se añadio un identificador interno para cada base de datos, esto hara que se puedan diferenciar en caso de que tengas una db con el mismo nombre en diferentes sub directorios.

V2.4.0

Se agrego 3 nuevos metodos (find, map, filter)

V1.9.0

Se agrego 3 nuevos metodos (size, keys, values)

V1.7.0

Se agregó el metodo purgeall.

V1.5.0

Se arregló el readme.

V1.4.0

Se arregló un bug en la funcion obtener.

Constructor:

Metodos:

Instalacion:

npm install megadb --save

Ejemplo del requerimiento del package:

const db = require('megadb');

crearDB(nombre_db, sub_directorio)

Este constructor te permite crear una base de datos.

Modo de uso

Este constructor tiene dos modos de uso:

Modo #1

Este modo es el que siempre se ha usado, aqui debes de especificar el nombre de la base de datos y el sub directorio(opcional).

En este modo por default la carpeta donde se almacenarán tus bases de datos será mega_databases, y si esta carpeta no existe se creará automaticamente.

nombre_db: Nombre del archivo con el que se creara la base de datos, si el nombre de la base de datos que pusiste ya existia, lo que hara es devolver los datos existentes de esa db.
sub_directorio (opcional): Este argumento es opcional, es para especificar si quieres que la base de datos se guarde en un sub diréctorio dentro de la carpeta mega_databases.

Ejemplo


//Ejemplo 1
const db = require('megadb');
let niveles = new db.crearDB('niveles');
/*
Esto hará que se cree la base de datos niveles.json dentro de la carpeta mega_databases

Estructura:

[–] node_modules
[+] mega_databases
    - niveles.json

*/

//Ejemplo 2
const db = require('megadb');
let economia = new db.crearDB('guild_1', 'economia_db');
/*
Esto hará que se cree un sub directorio llamado "economia_db" dentro de la carpeta mega_databases, y dentro de este sub directorio se creará la base de datos guild_1.json

Estructura:

[–] node_modules
[+] mega_databases
    [+] economia_db
        - guild_1.json
    - niveles.json
*/

Modo #2

Este modo te permite hacer lo mismo que el modo #1, la unica diferencia es que ahora puedes especificar el nombre de la carpeta donde se almacenaran tus bases de datos y tambien añadir la opcion de que tu base de datos no se llegue a reescribir rapidamente.

En este modo solo se puede hacer uso de un parametro la cual debe de contener un objeto con 3 propiedades:

nombre: Nombre del archivo con el que se creara la base de datos, si el nombre de la base de datos que pusiste ya existia, lo que hara es devolver los datos existentes de esa db, este parametro es obligatorio.
carpeta (opcional): Aqui deberas de colocar el nombre de la carpeta donde se guardaran tus bases de datos, si no colocas esta propiedad, por default será mega_databases.
sub (opcional): Esto tambien es opcional, aqui puedes especificar si quieres que la base de datos se guarde en un sub diréctorio dentro de la carpeta que especificaste en la propiedad carpeta.
guardar_tiempo (opcional): Aqui deberas de colocar el tiempo (en segundos) que se deberá esperar para actualizar los datos en la base de datos, debe ser mayor a 4 segundos (usalo con precaucion).

Ejemplo


//Ejemplo 1
const db = require('megadb');
let niveles = new db.crearDB({
  nombre: "levels",
  carpeta: "datos_niveles"
});
/*
Esto hará que se cree la base de datos levels.json dentro de la carpeta datos_niveles

Estructura:

[–] node_modules
[+] datos_niveles
    - levels.json

*/


//Ejemplo 2
const db = require('megadb');
let economia = new db.crearDB({
  nombre: 'usuarios',
  carpeta: "economia_db",
  sub: "dinero",
  guardar_tiempo: 5
});
/*
Esto hará que se cree un sub directorio llamado "dinero" dentro de la carpeta economia_db, y dentro de este sub directorio se creará la base de datos usuarios.json

Estructura:

[–] node_modules
[+] datos_niveles
    - levels.json
[+] economia_db
    [+] dinero
        - usuarios.json
*/

Recuerda

Cada base de datos tiene un indentificador interno, esto hará que se puedan diferenciar en caso de que uses una db con el mismo nombre en diferentes carpetas (ya sean sub directorios o la carpeta principal donde se guardan tus bases de datos).

Ten en cuenta que si usas el Modo #2 y quieres usar los datos de esa db en otro archivo, debes de colocar los mismos datos especificando el nombre, carpeta, sub y guardar_tiempo (en caso de hayas usado estas propiedades)

Si tu base de datos se modifica muchas veces en pequeños lapsos de tiempo (supongamos cada 1 segundo) se recomienda usar la propiedad guardar_tiempo del Modo #2, esto hará que tu base de datos(archivo) no se llegue a reescribir/actualizar rapidamente, obtenemos una mejor fluidez al momento de guardar los datos.

El constructor memoDB te permitira crear una base de datos en memoria de forma eficiente. Que quiere decir base de datos en memoria? Practicamente los datos que agregues no se guardaran en un archivo ya que se mantendran en la memoria interna de este package, recuerda que los datos que agregues se perderan cada vez que tu proyecto/app se apague o reinicie. Esto es perfecto para hacer cosas rapidas.

memoDB(nombre_db)

Argumentos

nombre_db: Nombre de la base de datos, en caso de que quieras obtener los datos de esta db en otro archivo, solo debes de colocar el mismo nombre.

Recuerda

No habrá ningun problema si colocas el nombre de una base de datos que esta siendo usada en el constructor crearDB, ambas dbs guardaran datos por separado.

Importante

Este constructor puede usar unicamente los siguientes metodos:

establecer
obtener
tiene
eliminar
purgeall
sumar
restar
push
extract
datos
ordenar
random
keys
values
size
find
filter
map
some
setIndex
delIndex
findKey
partition

Ejemplos


//Ejemplo 1
const db = require('megadb');
let puntajes = new db.memoDB('niveles');
/*
Esto hará que se cree la base de datos niveles en la memoria interna
*/

establecer(clave, valor, clave_split)

//[alias]
set(clave, valor, clave_split)

Este metodo te permite crear propiedades mediante una clave, tambien te permite actualizar datos existentes por nuevos.

Argumentos

clave: Aqui deberas de poner el nombre de la propiedad que quieres crear, puedes usar el . seguido de otro nombre para crear o para acceder a propiedades anidadas (el . es un signo por default, puedes cambiarlo en clave_split)
valor: Aqui deberas de poner el valor que recibira la propiedad que especificaste en el argumento clave.
clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para crear o para acceder a propiedades anidadas en el argumento clave (por default es el .)

Retorna

Promesa con los datos actualizados

Ejemplos

const db = require('megadb');
let niveles = new db.crearDB('niveles');

niveles.establecer('MegaStar', {xp: 0, nivel: 10}) // retorna una promesa: {MegaStar: {xp: 0, nivel: 10}}
niveles.establecer('MegaStar.xp', 100) // retorna una promesa: {MegaStar: {xp: 100, nivel: 10}}
niveles.establecer('MoDeR', 100) // retorna una promesa: {MegaStar: {xp: 100, nivel: 10}, MoDeR: 100}
niveles.establecer('MoDeR-datos-monedas', 200, "-") // retorna una promesa: {MegaStar: {xp: 100, nivel: 10}, MoDeR: {datos: {monedas: 200}}}
niveles.establecer('MoDeR.datos.banco', 1000) // retorna una promesa:{MegaStar: {xp: 100, nivel: 10}, MoDeR: {datos: {monedas: 200, banco: 1000}}}
niveles.establecer('RatSageM', []) // retorna una promesa: {MegaStar: {xp: 100, nivel: 10}, MoDeR: {datos: {monedas: 200, banco: 1000}}, RatSageM: []}

//Estructura de la base de datos niveles.json:
{
  "MegaStar": {
    "xp": 100,
    "nivel": 10
  },
  "MoDeR": {
    "datos": {
      "monedas": 200,
      "banco": 1000
    }
  },
  "RatSageM": []
}

size()

Este metodo te permite obtener el numero de valores(claves/keys) de una base de datos.

Argumentos

Ninguno

Retorna

Retorna el numero de valores de la base de datos(claves/keys).

Ejemplos

const db = require('megadb');
let niveles = new db.crearDB('niveles');

let length = niveles.size()
console.log(length) //Esto retorna 3 ya que solo hemos agregado 3 valores(claves): MegaStar, MoDeR y RatSageM

obtener(clave, clave_split)

//[alias]
get(clave, clave_split)

Este metodo te permite obtener los datos(valores) de una propiedad especifica.

Argumentos

clave: Aqui deberas de poner el nombre de la propiedad que quieres obtener, puedes usar el . seguido de otro nombre para acceder a propiedades anidadas (el . es un signo por default, puedes cambiarlo en clave_split)
clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidada en el argumento clave (por default es el .)

Retorna

Promesa con los datos que se obtuvo, de lo contrario undefined.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes obtenerlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

const db = require('megadb');
let niveles = new db.crearDB('niveles');

niveles.obtener('MegaStar') // retorna promesa: {xp: 100, nivel: 10}
niveles.obtener('MegaStar.nivel') // retorna promesa: 10
niveles.obtener('MoDeR-datos-banco', "-") // retorna promesa: 1000
niveles.obtener('Star') //retorna promesa: undefined

tiene(clave, clave_split)

//[alias]
has(clave, clave_split)

Este metodo te permite verificar si existe una propiedad especifica.

Argumentos

clave: Aqui deberas de poner el nombre de la propiedad que quieres verificar, puedes usar el . seguido de otro nombre para acceder a propiedades anidadas (el . es un signo por default, puedes cambiarlo en clave_split)
clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidada en el argumento clave (por default es el .)

Retorna

true si la propiedad existe.
false si la propiedad no existe.

Ejemplos

const db = require('megadb');
let niveles = new db.crearDB('niveles');

niveles.tiene('MegaStar') // retorna true
niveles.tiene('Mario') // retorna false
niveles.tiene('MegaStar.monedas') // retorna false
niveles.tiene('MoDeR-datos-monedas', "-") // retorna true

eliminar(clave, clave_split)

//[alias]
delete(clave, clave_split)

Este metodo te permite eliminar una propiedad especifica.

Argumentos

clave: Aqui deberas de poner el nombre de la propiedad que quieres eliminar, puedes usar el . seguido de otro nombre para acceder a propiedades anidadas (el . es un signo por default, puedes cambiarlo en clave_split)
clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidada en el argumento clave (por default es el .)

Retorna

true si la propiedad se elimino correctamente.
false si la propiedad no se elimino (no existe).

Ejemplos

const db = require('megadb');
let niveles = new db.crearDB('niveles');

niveles.eliminar('MegaStar.xp') //retorna true
niveles.eliminar('MoDeR.datos.banco') //retorna true
niveles.eliminar('Mario') //retorna false


niveles.tiene('MoDeR.datos.banco') // retorna false porque lo eliminamos
niveles.tiene('MegaStar.xp') // retorna false porque lo eliminamos

niveles.obtener('MegaStar') // retorna promesa: {nivel: 10}
niveles.obtener('MoDeR-datos', "-") // retorna promesa: {monedas: 200}


//Estructura actual de la base de datos niveles.json:
{
  "MegaStar": {
    "nivel": 10
  },
  "MoDeR": {
    "datos": {
      "monedas": 200
    }
  },
  "RatSageM": []
}

datos()

Este metodo regresa todas las propiedades de la base de datos, en otras palabras todos los datos.

Argumentos

Ninguno

Retorna

Promesa con todos los datos.

Ejemplos

const db = require('megadb');
let niveles = new db.crearDB('niveles');

niveles.datos().then(n => {
  console.log(n)
})

//console.log(n)
{
  "MegaStar": {
    "nivel": 10
  },
  "MoDeR": {
    "datos": {
      "monedas": 100
    }
  },
  "RatSageM": []
}

push(clave, valor, clave_split)

Este metodo te permite agregar un elemento a un array.

Argumentos

clave: Aqui deberas de poner el nombre de la propiedad a la que quieres agregar el elemento, puedes usar el . seguido de otro nombre para acceder a propiedades anidadas (el . es un signo por default, puedes cambiarlo en clave_split)
valor: Aqui deberas de poner el elemento que se agregara en el array que especificaste en el argumento clave.
clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidadas en el argumento clave (por default es el .)

Retorna

Promesa con el array actualizado.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes obtenerlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

const db = require('megadb');
let niveles = new db.crearDB('niveles');

niveles.push('RatSageM', 'manzana') // retorna promesa: ["manzana"]
niveles.establecer('MGstar', {items: ["platano"]})
//retorna promesa: {MegaStar: {nivel: 10}, MoDeR: {datos: {monedas: 100}}, RatSageM: ["manzana"], Mgstar: {items: ["platano"]}}

niveles.push('MGstar', 'sandia') // retorna Error (.catch)
niveles.push('MGstar.items', 'sandia') // retorna promesa: ["platano", "sandia"]


//Estructura actual de la base de datos niveles.json:
{
  "MegaStar": {
    "nivel": 10
  },
  "MoDeR": {
    "datos": {
      "monedas": 200
    }
  },
  "RatSageM": ["manzana"],
  "MGstar": {
    "items": ["platano", "sandia"]
  }
}

extract(clave, valor, clave_split)

Este metodo te permite remover un elemento especifico de un array.

Argumentos

clave: Aqui deberas de poner el nombre de la propiedad a la que quieres remover el elemento, puedes usar el . seguido de otro nombre para acceder a propiedades anidadas (el . es un signo por default, puedes cambiarlo en clave_split)
valor: Aqui deberas de poner el elemento que se removera del array que especificaste en el argumento clave.
clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidadas en el argumento clave (por default es el .)

Retorna

Promesa con el array actualizado.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes obtenerlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

const db = require('megadb');
let niveles = new db.crearDB('niveles');

niveles.extract('MGstar', 'platano') // retorna Error (.catch)
niveles.extract('RatSageM', 'manzana') // retorna promesa: []
niveles.extract('MGstar.items', 'platano') // retorna promesa: ["sandia"]
niveles.extract('MGstar.items', 'durazno') // retorna Error (.catch)


//Estructura actual de la base de datos niveles.json:
{
  "MegaStar": {
    "nivel": 10
  },
  "MoDeR": {
    "datos": {
      "monedas": 200
    }
  },
  "RatSageM": [],
  "MGstar": {
    "items": ["sandia"]
  }
}

sumar(clave, valor, clave_split)

//[alias]
add(clave, valor, clave_split)

Este metodo te permite sumar una cantidad especifica a una propiedad, el valor propiedad debe ser un numero.

Argumentos

clave: Aqui deberas de poner el nombre de la propiedad a la que quieres sumarle una cantidad especifica, puedes usar el . seguido de otro nombre para acceder a propiedades anidadas (el . es un signo por default, puedes cambiarlo en clave_split)
valor: Aqui deberas de poner la cantidad que se le sumara a la propiedad que especificaste en el argumento clave, esto debe ser un numero.
clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidadas en el argumento clave (por default es el .)

Retorna

Promesa con el valor actualizado.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes obtenerlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

const db = require('megadb');
let niveles = new db.crearDB('niveles');

niveles.establecer('Nelson', 20)
//retorna promesa: {MegaStar: {nivel: 10}, MoDeR: {datos: {monedas: 200}}, RatSageM: [], MGstar: {items: ["sandia"]}, Nelson: 20}

niveles.sumar('Nelson', 25) //retorna promesa: 45
niveles.establecer('Sun.datos.monedas', 10)
//retorna promesa: {MegaStar: {nivel: 10}, MoDeR: {datos: {monedas: 200}}, RatSageM: [], MGstar: {items: ["sandia"]}, Nelson: 20, Sun: {datos: {monedas: 10}}}

niveles.sumar('Sun.datos', 90) // retorna Error (.catch)
niveles.sumar('Sun-datos-monedas', 90, "-") // retorna promesa: 100

console.log(niveles.size()) //Esto imprime 6 ya que hemos agregado 6 valores(claves): MegaStar, MoDeR, RatSageM, MGstar, Nelson y Sun

//Estructura actual de la base de datos niveles.json:
{
  "MegaStar": {
    "nivel": 10
  },
  "MoDeR": {
    "datos": {
      "monedas": 200
    }
  },
  "RatSageM": [],
  "MGstar": {
    "items": ["sandia"]
  },
  "Nelson": 45,
  "Sun": {
    "datos": {
      "monedas": 100
    }
  }
}

restar(clave, valor, clave_split)

//[alias]
subtract(clave, valor, clave_split)

Este metodo te permite restar una cantidad especifica a una propiedad, el valor propiedad debe ser un numero.

Argumentos

clave: Aqui deberas de poner el nombre de la propiedad a la que quieres restarle una cantidad especifica, puedes usar el . seguido de otro nombre para acceder a propiedades anidadas (el . es un signo por default, puedes cambiarlo en clave_split)
valor: Aqui deberas de poner la cantidad que se le restara a la propiedad que especificaste en el argumento clave, esto debe ser un numero.
clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidadas en el argumento clave (por default es el .)

Retorna

Promesa con el valor actualizado.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes obtenerlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

const db = require('megadb');
let niveles = new db.crearDB('niveles');

niveles.restar('Nelson', 40) //retorna promesa: 5
niveles.restar('Sun.datos', 100) // retorna Error (.catch)
niveles.restar('Sun-datos-monedas', 100, "-") // retorna promesa: 0


//Estructura actual de la base de datos niveles.json:
{
  "MegaStar": {
    "nivel": 10
  },
  "MoDeR": {
    "datos": {
      "monedas": 200
    }
  },
  "RatSageM": [],
  "MGstar": {
    "items": ["sandia"]
  },
  "Nelson": 5,
  "Sun": {
    "datos": {
      "monedas": 0
    }
  }
}

keys(clave, clave_split)

Este metodo retorna un array con todos los nombres(keys) de las propiedades del objeto que especificaste.

Argumentos

clave (opcional): La clave es opcional, en el caso de que quieras obtener los nombres(keys) de un objeto especifico, puedes colocar el nombre del objeto. Si quieres obtener los nombres(keys) de un objeto anidado, puedes usar el . seguido del nombre del objeto anidado (el . es un signo por default, puedes cambiarlo en clave_split) En el caso de que directamente quieras obtener los nombres(keys) de una base de datos, no pongas ningun valor.
clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidadas en el argumento clave (por default es el .)

Retorna

Promesa con un array que contiene los nombres de las propiedades(keys).

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes obtenerlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

const db = require('megadb');
let niveles = new db.crearDB('niveles');

niveles.keys() //retorna promesa: ["MegaStar", "MoDeR", "RatSageM", "MGstar", "Nelson", "Sun"]
niveles.keys('MegaStar.nivel') // retorna Error (.catch)
niveles.keys('Sun.datos') ///retorna promesa: ["monedas"]

values(clave, clave_split)

Este metodo retorna un array con todos los valores de las propiedades del objeto que especificaste.

Argumentos

clave (opcional): La clave es opcional, en el caso de que quieras obtener los valores de un objeto especifico, puedes colocar el nombre del objeto. Si quieres obtener los valores de un objeto anidado, puedes usar el . seguido del nombre del objeto anidado (el . es un signo por default, puedes cambiarlo en clave_split) En el caso de que directamente quieras obtener los valores de una base de datos, no pongas ningun valor.
clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidadas en el argumento clave (por default es el .)

Retorna

Promesa con un array que contiene los valores de las propiedades.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes obtenerlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

const db = require('megadb');
let niveles = new db.crearDB('niveles');

niveles.values() //retorna promesa: [{nivel: 10}, {datos: {monedas: 200}}, [], {items: ["sandia"]}, {datos: {monedas:0}}]

niveles.values('MegaStar.nivel') // retorna Error (.catch)
niveles.values('Sun.datos') ///retorna promesa: [{monedas: 0}]

purgeall()

Este metodo te permite eliminar todos los datos de una base de datos especifica.

Argumentos

Ninguno

Retorna

true si se elimino todo correctamente.
false si no se elimino correctamente.

Ejemplos

const db = require('megadb');
let niveles = new db.crearDB('niveles');

//Estructura actual de la base de datos niveles.json:
{
  "MegaStar": {
    "nivel": 10
  },
  "MoDeR": {
    "datos": {
      "monedas": 200
    }
  },
  "RatSageM": [],
  "MGstar": {
    "items": ["sandia"]
  },
  "Nelson": 5,
  "Sun": {
    "datos": {
      "monedas": 0
    }
  }
}


let status = niveles.purgeall()
console.log(status) //Esto retorna true

//Estructura actual de la base de datos niveles.json:
{} //No contiene nada ya que se elimino todo

ordenar(clave, valor, clave_split)

//[alias]
sort(clave, valor, clave_split)

Este metodo te permite ordenar las propiedad de un objeto de forma descendente, ten en cuenta que el valor de las propiedades que quieras ordenar debe ser un numero.

Argumentos

clave: La clave puede recibir dos tipos de valores, en el caso de que quieras ordenar las propiedades de un objeto especifico, puedes colocar el nombre del objeto. Si quieres ordenar las propiedades de un objeto anidado, puedes usar el . seguido del nombre del objeto anidado (el . es un signo por default, puedes cambiarlo en clave_split) Puedes usar false en caso de que directamente quieras ordenar las propiedades de una base de datos.
valor: El valor tambien puede recibir dos tipos de valores, en el caso de que las propiedades del objeto que quieres ordenar tambien sean objetos y mantengan propiedades, puedes colocar el nombre de la propiedad que se usara como referencia para ordenarlos de forma descendente, en el caso de que estas propiedades tambien sean objetos, puedes usar el . seguido del nombre del objeto y la propiedad que quieres ordenar (el . es un signo por default, puedes cambiarlo en clave_split) Puedes usar false en caso de que el valor de la propiedad con la cual lo vas a ordenar no sea un objeto.
clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidadas en el argumento clave y el argumento valor (por default es el .)

Retorna

Promesa con un array, este array contiene las propiedades ordenadas de forma descendente.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes obtenerlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

//ejemplo_1

const db = require('megadb');
let economia = new db.crearDB('guild_1', 'economia_db');

economia.establecer('MegaStar', 100)
economia.establecer('MoDeR', 40)
economia.establecer('ratsagem', 320)

/*
Estructura actual de la base de datos guild_1.json:

{
  "MegaStar": 100,
  "MoDeR": 40,
  "ratsagem": 320
}

*/

economia.ordenar(false, false)
//retorna promesa: [{clave: 'ratsagem', valor: 320}, {clave: 'MegaStar', valor: 100}, {clave: 'MoDeR', valor: 40}]


/////////////////////////////////////////////////////


//ejemplo_2
const db = require('megadb');
let economia = new db.crearDB('guild_1', 'economia_db');
economia.establecer('MegaStar', {monedas: 100})
economia.establecer('MoDeR', {monedas: 40})
economia.establecer('ratsagem', {monedas: 320})

/*
Estructura actual de la base de datos guild_1.json:

{
  "MegaStar": {
    "monedas": 100
  },
  "MoDeR": {
    "monedas": 40
  },
  "ratsagem": {
    "monedas": 320
  }
}

*/

economia.ordenar(false, "monedas")
//retorna promesa: [{clave: 'ratsagem', valor: {monedas: 320)}, {clave: 'MegaStar', valor: {monedas: 100}}, {clave: 'MoDeR', valor: {monedas: 40)}]


/////////////////////////////////////////////////////


//ejemplo_3
const db = require('megadb');
let economia = new db.crearDB('guild_2', 'economia_db');
let usuarios_data = {
  'MegaStar': 100,
  'MoDeR': 40,
  'ratsagem': 320
}
economia.establecer('usuarios', usuarios_data)

/*
Estructura actual de la base de datos guild_2.json:

{
  "usuarios": {
    "MegaStar": 100
    "MoDeR": 40
    "ratsagem": 320
  }
}

*/

economia.ordenar("usuarios", false)
//retorna promesa: [{clave: 'ratsagem', valor: 320}, {clave: 'MegaStar', valor: 100}, {clave: 'MoDeR', valor: 40}]


/////////////////////////////////////////////////////


//ejemplo_4
const db = require('megadb');
let economia = new db.crearDB('guild_3', 'economia_db');
let usuarios_data = {
  "MegaStar": {monedas: 50},
  "MoDeR": {monedas: 67},
  "ratsagem": {monedas: 4}
}
economia.establecer('usuarios', usuarios_data)


/*
Estructura actual de la base de datos guild_3.json:

{
  "usuarios": {
    "MegaStar": {
      "monedas": 50
    },
    "MoDeR": {
      "monedas": 67
    },
    "ratsagem": {
      "monedas": 4
    }
  }
}

*/

economia.ordenar("usuarios", "monedas")
//retorna promesa: [{clave: 'MoDeR', valor: {monedas: 67)}, {clave: 'MegaStar', valor: {monedas: 50}}, {clave: 'ratsagem', valor: {monedas: 4)}]


/////////////////////////////////////////////////////


//ejemplo_5
const db = require('megadb');
let economia = new db.crearDB('guild_4', 'economia_db');

let usuarios = {
  "megastar": {monedas: 10, medallas: 15},
  "moder": {monedas: 50, medallas: 20},
  "ratsagem": {monedas: 25, medallas: 5}
}
economia.establecer('servidores.datos', usuarios)

/*
Estructura actual de la base de datos guild_4.json:

{
 'servidores': {
    'datos': {
      'megastar': {
        'monedas': 10,
        'medallas': 15
      },
      'moder': {
        'monedas': 50,
        'medallas': 20
      },
      'ratsagem': {
        'monedas': 25,
        'medallas': 5
      }
    }
  }
}

*/

economia.ordenar('servidores.datos', "medallas")

/*
retorna promesa:

[
  {clave: 'moder', valor: {monedas: 50, medallas: 20}},
  {clave: 'MegaStar', valor: {monedas: 10, medallas: 15}},
  {clave: 'ratsagem', valor: {monedas: 25, medallas: 5}}
]

*/



/////////////////////////////////////////////////////


//ejemplo_6
const db = require('megadb');
let economia = new db.crearDB('guild_5', 'economia_db');

let usuarios = {
  "megastar": {stats: {monedas: 10}},
  "moder": {stats: {monedas: 50}},
  "ratsagem": {stats: {monedas: 25}}
}
economia.establecer('servidores.datos', usuarios)

/*
Estructura actual de la base de datos guild_5.json:

{
 'servidores': {
    'datos': {
      'megastar': {
        'stats': {
          'monedas': 10
        }
      },
      'moder': {
        'stats': {
          'monedas': 50
        }
      },
      'ratsagem': {
        'stats': {
          'monedas': 25
        }
      }
    }
  }
}

*/

economia.ordenar('servidores-datos', "stats-monedas", "-") //Estoy usando el - como separador en lugar del .

/*
retorna promesa:

[
  {clave: 'moder', valor: {stats: {monedas: 50}}},
  {clave: 'ratsagem', valor: {stats: {monedas: 25}}},
  {clave: 'megastar', valor: {stats: {monedas: 10}}}
]

*/

random(clave, cantidad, clave_split)

Este metodo te permite obtener una cantidad especifica de propiedades aleatoriamente (random), nunca se repetiran.

Argumentos

clave: La clave puede recibir dos tipos de valores, en el caso de que quieras obtener aleatoriamente una cantidad especifica de propiedades de un objeto, puedes colocar el nombre del objeto. Si quieres obtener aleatoriamente una cantidad especifica de propiedades de un objeto anidado, puedes usar el . seguido del nombre del objeto anidado (el . es un signo por default, puedes cambiarlo en clave_split) Puedes usar false en caso de que tengas propiedades que no sean objetos anidados.
cantidad: Aqui deberas de poner la cantidad(un numero) de propiedades random que se obtendra del objeto que especificaste en el argumento clave.
clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidadas en el argumento clave (por default es el .)

Retorna

Promesa con un array, este array contiene las propiedades que fueron seleccionadas aleatoriamente.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes obtenerlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos

//ejemplo_1
const db = require('megadb');
let giveaway = new db.crearDB('giveaway');

giveaway.establecer('MegaStar', {ganadas: 0})
giveaway.establecer('MoDeR', {ganadas: 0})
giveaway.establecer('ratsagem', {ganadas: 0})
giveaway.establecer('Sun', {ganadas: 0})
giveaway.establecer('MGstar', {ganadas: 0})
giveaway.establecer('ruru', {ganadas: 0})

//Estructura actual de la base de datos giveaway.json:
{
  "MegaStar": {
    "ganadas": 0
  },
  "MoDeR": {
    "ganadas": 0
  },
  "ratsagem": {
    "ganadas": 0
  },
  "pedro": {
    "ganadas": 0
  },
  "MGstar": {
    "ganadas": 0
  },
  "ruru":  {
    "ganadas": 0
  }
}

giveaway.random(false, 4)
//retorna una promesa (las propiedades son aleatorias, esto es solo un ejemplo):
/*

[
  {clave: MegaStar, valor: {ganadas: 0}},
  {clave: ruru, valor: {ganadas: 0}},
  {clave: pedro, valor: {ganadas: 0}},
  {clave: MoDeR, valor: {ganadas: 0}}
]

*/


/////////////////////////////////////////////////////


//ejemplo_2
const db = require('megadb');
let giveaway = new db.crearDB('giveaway1');
let usuarios = {
  "12132131231242343": {ganadas: 0},
  "12132454545454543": {ganadas: 2},
  "13243242342342343": {ganadas: 1},
  "12138786867868683": {ganadas: 6},
  "18989896797978973": {ganadas: 0},
  "12121212135345346":  {ganadas: 5}
}
giveaway.establecer('users_ID', usuarios)


//Estructura actual de la base de datos giveaway1.json:
{
  "users_ID": {
    "12132131231242343": {
      "ganadas": 0
    },
    "12132454545454543": {
      "ganadas": 2
    },
    "13243242342342343": {
      "ganadas": 1
    },
    "12138786867868683": {
      "ganadas": 6
    },
    "18989896797978973": {
      "ganadas": 0
    },
    "12121212135345346":  {
      "ganadas": 5
    }
  }
}

giveaway.random("users_ID", 3)
//retorna una promesa (las propiedades son aleatorias, esto es solo un ejemplo):
/*

[
  {clave: 13243242342342343, valor: {ganadas: 1}},
  {clave: 12138786867868683, valor: {ganadas: 6}},
  {clave: 12121212135345346, valor: {ganadas: 5}}
]

*/

existeDB(nombre_db)

Este metodo te permite verificar si existe una especifica base de datos en la carpeta mega_databases o en sub directorio.

Argumentos

nombre_db: Aqui debe de ir el nombre de la base de datos que quires verificar si existe, si usaste la opcion del sub directorio en el constructor crearDB, esto automaticamente buscara en el sub directorio, de lo contrario se buscara en la carpeta mega_databases si no usaste esta opcion.

Retorna

true si la base de datos existe.
false si la base de datos no existe.

Ejemplos

/*
Nuestra estructura de dbs deberia ser esta:

[–] node_modules
[+] mega_databases
    [+] economia_db
        - guild_1.json
        - guild_2.json
        - guild_3.json
        - guild_4.json
        - guild_5.json
    - niveles.json
    - giveaway.json
    - giveaway1.json
*/

//ejemplo_1 usare un sub directorio
const db = require("megadb");
let economia = new db.crearDB("guild_1", "economia_db") //Estoy obteniendo el archivo guild_1.json que esta dentro del sub directorio "economia_db"
console.log(economia.existeDB("guild_2")) //retorna true
console.log(economia.existeDB("guild_5")) //retorna true
console.log(economia.existeDB("guild_8")) //retorna false
console.log(economia.existeDB("niveles")) //retorna false


//ejemplo_2 sin usar sub directorio
const db = require("megadb");
let niveles = new db.crearDB("niveles") //Estoy obteniendo el archivo niveles.json que esta dentro de la carpeta mega_databases
console.log(niveles.existeDB("giveaway")) //retorna true
console.log(niveles.existeDB("giveaway1")) //retorna true
console.log(niveles.existeDB("guild_8")) //retorna false
console.log(niveles.existeDB("mydb")) //retorna false

find(clave, callback(), clave_split)

Este metodo retorna el valor de la primera propiedad que cumpla la condicion del callback, si no encuentra nada regresara undefined. Es similar al Array.find

Argumentos

clave: La clave puede recibir dos tipos de valores, en el caso de que quieras buscar en las propiedades de un objeto especifico, puedes colocar el nombre del objeto. Si quieres buscar en las propiedades de un objeto anidado, puedes usar el . seguido del nombre del objeto anidado (el . es un signo por default, puedes cambiarlo en clave_split) Puedes usar false en caso de que directamente quieras buscar en las propiedades de una base de datos.
callback(valor_actual, clave_actual) : Aqui deberas de poner la funcion que se ejecutara o evaluara sobre cada elemento iterado del objeto que especificaste en el argumento clave, el callback puede recibir 2 argumentos:

valor_actual (opcional): Aqui se mostrara el valor del elemento que se esta procesando en ese momento.
clave_actual (opcional): Aqui se mostrara la clave del elemento que se esta procesando en ese momento.

clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidadas en el argumento clave (por default es el .)

Retorna

Esto retornara una promesa con el valor de la primera propiedad que cumpla la condicion del callback, de lo contrario retornara undefined.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes obtenerlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos


//ejemplo_1
const db = require("megadb");
let escuela = new db.crearDB("escuela")

escuela.establecer('Mario', {edad: 15, apellido: "garcia"})
escuela.establecer('Pedro', {edad: 12, apellido: "rojas"})
escuela.establecer('Juan', {edad: 10, apellido: "perez"})
escuela.establecer('Jair', {edad: 16, apellido: "gonzales"})

/* Estructura actual de la base de datos escuela.json:

{
  "Mario": {
    "edad: 15,
    "apellido: "garcia"
  },
  "Pedro": {
    "edad: 12,
    "apellido: "rojas"
  },
  "Juan": {
    "edad: 10,
    "apellido: "perez"
  },
  "Jair": {
    "edad: 16,
    "apellido: "gonzales"
  }
}

*/

escuela.find(false, (v) => v.edad == 16).then(nuevos => { //v es el elemento que se esta procesando en ese momento

  /* Ahora nuevos debera de contener esto:
    {
      "edad": "16",
      "apellido": "gonzales"
    }
  */

  if(nuevos == undefined) return console.log("Ningun alumno tiene 16 años")
  return console.log(`El alumno ${nuevos.apellido} tiene ${nuevos.edad} años!`)
}).catch(error => console.log(error))

//Esto da como resultado: "El alumno gonzales tiene 16 años!"


/////////////////////////////////////////////////////


//ejemplo_2
const db = require("megadb");
let registros = new db.crearDB("registros")

let registrados = {
  "ID_1": {
    "username": "MegaStar",
    "password": "xxxxxxxx",
    "age": 20
  },
  "ID_2": {
    "username": "MoDeR",
    "password": "aaaaaaaa",
    "age": 19
  },
  "ID_3": {
    "username": "RatSageM",
    "password": "cccccccc",
    "age": 18
  }
}

registros.establecer('usuarios', registrados)

/* Estructura actual de la base de datos registros.json:

{
  "usuarios": {
    "ID_1": {
      "username": "MegaStar",
      "password": "xxxxxxxx",
      "edad": 20
    },
    "ID_2": {
      "username": "MoDeR",
      "password": "aaaaaaaa",
      "edad": 19
    },
    "ID_3": {
      "username": "RatSageM",
      "password": "cccccccc",
      "edad": 18
    }
  }
}

*/

registros.find("usuarios", (v) => v.username == "MegaStar").then(usuario => { //v es el elemento del objeto "usuarios" que se esta procesando en ese momento

  /* Ahora usuario debera de contener esto:
    {
      "username": "MegaStar",
      "password": "xxxxxxxx",
      "edad": 20
    }
  */

  if(usuario == undefined) return console.log("No existe este usuario.")
  let nombre = usuario.username
  let contra = usuario.password
  let edad = usuario.edad
  return console.log(`Datos, username: ${nombre}, contraseña: ${contra}, edad: ${edad}`)
}).catch(error => console.log(error))

//Esto da como resultado: "Datos, username: MegaStar, contraseña: xxxxxxxx, edad: 20"

filter(clave, callback(), clave_split)

Este metodo retorna un objeto con todas las propiedades que cumplan la condicion del callback, si no encuentra nada regresara un objeto vacio {}. Es similar al Array.filter solo que en vez de regresar un nuevo array, regresa un nuevo objeto.

Argumentos

clave: La clave puede recibir dos tipos de valores, en el caso de que quieras buscar en las propiedades de un objeto especifico, puedes colocar el nombre del objeto. Si quieres buscar en las propiedades de un objeto anidado, puedes usar el . seguido del nombre del objeto anidado (el . es un signo por default, puedes cambiarlo en clave_split) Puedes usar false en caso de que directamente quieras buscar en las propiedades de una base de datos.
callback(valor_actual, clave_actual): Aqui deberas de poner la funcion que se ejecutara o evaluara sobre cada elemento iterado del objeto que especificaste en el argumento clave, el callback puede recibir 2 argumentos:

valor_actual (opcional): Aqui se mostrara el valor del elemento que se esta procesando en ese momento.
clave_actual (opcional): Aqui se mostrara la clave del elemento que se esta procesando en ese momento.

clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidadas en el argumento clave (por default es el .)

Retorna

Esto retornara una promesa con un objeto que contiene todas las propiedades que cumplan la condicion del callback, de lo contrario retornara un objeto vacio {}.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes obtenerlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos


//ejemplo_1
const db = require("megadb");
let seleccion = new db.crearDB("seleccion")

seleccion.establecer('Mario', 18)
seleccion.establecer('Pedro', 20)
seleccion.establecer('Juan', 12)
seleccion.establecer('Jair', 13)
seleccion.establecer('Steve', 16)
seleccion.establecer('Axel', 10)

/* Estructura actual de la base de datos seleccion.json:

{
  "Mario": 18,
  "Pedro": 20,
  "Juan": 12,
  "Jair": 13,
  "Steve": 16,
  "Axel": 10
}

*/

seleccion.filter(false, (v) => v > 15).then(nuevos => { //Estoy especificando que el valor del elemento que se esta procesando sea mayor a 15

  /* Ahora nuevos debera de contener este objeto:
    {
      "Mario": 18,
      "Pedro": 20,
      "Steve": 16
    }
  */

  if(Object.keys(nuevos).length <= 0) return console.log("Ningun jugador tiene mas de 15 años")
  let jugadores = []
  for(var key in nuevos) {
    jugadores.push(`Nombre: ${key}, edad: ${nuevos[key]}`)
  }
  return console.log(jugadores.join("\n"))
})

/*Esto da como resultado:

Nombre: Mario, edad: 18
Nombre: Pedro, edad: 20
Nombre: Steve, edad: 16

*/


/////////////////////////////////////////////////////


//ejemplo_2
const db = require("megadb");
let registros2 = new db.crearDB("registros2")

let registrados = {
  "ID_1": {
    "username": "MegaStar",
    "password": "xxxxxxxx",
    "lenguaje": "javascript"    
    "age": 20
  },
  "ID_2": {
    "username": "MoDeR",
    "password": "aaaaaaaa",
    "lenguaje": "javascript"    
    "age": 19
  },
  "ID_3": {
    "username": "RatSageM",
    "password": "cccccccc",
    "lenguaje": "c++"    
    "age": 18
  }
}

registros2.establecer('users', registrados)

/* Estructura actual de la base de datos registros2.json:

{
  "users": {
    "ID_1": {
      "username": "MegaStar",
      "password": "xxxxxxxx",
      "lenguaje": "javascript"       
      "edad": 20
    },
    "ID_2": {
      "username": "MoDeR",
      "password": "aaaaaaaa",
      "lenguaje": "javascript"       
      "edad": 19
    },
    "ID_3": {
      "username": "RatSageM",
      "password": "cccccccc",
      "lenguaje": "c++"     
      "edad": 18
    }
  }
}

*/

registros2.filter("users", (v) => v.lenguaje == "javascript").then(usuarios => {

  /* Ahora usuarios debera de contener este objeto:
    {
      "ID_1": {
        "username": "MegaStar",
        "password": "xxxxxxxx",
        "lenguaje": "javascript"       
        "edad": 20
      },
      "ID_2": {
        "username": "MoDeR",
        "password": "aaaaaaaa",
        "lenguaje": "javascript"       
        "edad": 19
      }
    }
  */
  if(Object.keys(usuarios).length <= 0) return console.log("Ningun usuario sabe javascript.")
  let lista = []

  for(var key in usuarios) {
    let nombre = usuarios[key].username
    let edad = usuarios[key].edad
    let lenguaje = usuarios[key].lenguaje

    lista.push(`[${key}] username: ${nombre}, edad: ${edad}, lenguaje: ${lenguaje}`)
  }
  return console.log(lista.join("\n"))
})

/*Esto da como resultado:

[ID_1] username: MegaStar, edad: 20, lenguaje: javascript
[ID_2] username: MoDeR, edad: 18, lenguaje: javascript

*/

map(clave, callback(), clave_split)

Este metodo retorna un array con los resultados de la condicion que se especifico en el callback. Es similar al Array.map

Argumentos

clave: La clave puede recibir dos tipos de valores, en el caso de que quieras buscar en las propiedades de un objeto especifico, puedes colocar el nombre del objeto. Si quieres buscar en las propiedades de un objeto anidado, puedes usar el . seguido del nombre del objeto anidado (el . es un signo por default, puedes cambiarlo en clave_split) Puedes usar false en caso de que directamente quieras buscar en las propiedades de una base de datos.
callback(valor_actual, clave_actual): Aqui deberas de poner la funcion que se ejecutara o evaluara sobre cada elemento iterado del objeto que especificaste en el argumento clave, el callback puede recibir 2 argumentos:

valor_actual (opcional): Aqui se mostrara el valor del elemento que se esta procesando en ese momento.
clave_actual (opcional): Aqui se mostrara la clave del elemento que se esta procesando en ese momento.

clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidadas en el argumento clave (por default es el .)

Retorna

Esto retornara una promesa con un array que contiene todos los resultados que se especificó en el callback.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes obtenerlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos


//ejemplo_1
const db = require("megadb");
let puntaje = new db.crearDB("puntajes")

puntaje.establecer('Mario', 2)
puntaje.establecer('Pedro', 4)
puntaje.establecer('Juan', 5)
puntaje.establecer('Jair', 6)

/* Estructura actual de la base de datos puntajes.json:

{
  "Mario": 2,
  "Pedro": 4,
  "Juan": 5,
  "Jair": 6
}

*/

puntaje.map(false, (v, key) => `Usuario: ${key}, puntaje: ${v*2}`).then(datos => { //v toma el valor del elemento que se esta procesando en ese momento, y key toma la clave del elemento que se esta procesando en ese momento

  /* Ahora datos debera de contener este array:

    ["Usuario: Mario, puntaje: 4",
     "Usuario: Pedro, puntaje: 8",
     "Usuario: Juan, puntaje: 10",
     "Usuario: Jair, puntaje: 12"]
  */

  return console.log(datos.join("\n"))
})

/*Esto da como resultado:

Usuario: Mario, puntaje: 4
Usuario: Pedro, puntaje: 8
Usuario: Juan, puntaje: 10
Usuario: Jair, puntaje: 12

*/


/////////////////////////////////////////////////////


//ejemplo_2
const db = require("megadb");
let users_lb = new db.crearDB("userslb")

let usuarios = {
  "servidor_1": {
    "MegaStar": 8,   
    "MoDeR": 6,
    "Mario": 1,
    "Pedro": 8
  },
  "servidor_2": {
    "Juan": 4,   
    "RatSageM": 5,
    "Steve": 7
  },
  "servidor:3": {
    "reDoM": 1,
    "Jack": 4
  }
}

users_lb.establecer('leaderboard', usuarios)

/* Estructura actual de la base de datos userslb.json:

{
  "leaderboard": {
    "servidor_1": {
      "MegaStar": 8,   
      "MoDeR": 6,
      "Mario": 1,
      "Pedro": 8
    },
    "servidor_2": {
      "Juan": 4,   
      "RatSageM": 5,
      "Steve": 7
    },
    "servidor_3": {
      "reDoM": 1,
      "Jack": 4
    }
  }
}

*/

users_lb.map("leaderboard.servidor_1", (v, key) => `Usuario: ${key} | puntos: ${v*3}`).then(usuarios => {

  /* Ahora usuarios debera de contener este array:

  ["Usuario: MegaStar | puntos: 24",
   "Usuario: MoDeR | puntos: 18",
   "Usuario: Mario | puntos: 3",
   "Usuario: Pedro | puntos: 24"]

  */

  return console.log(usuarios.join("\n"))
})

/*Esto da como resultado:

Usuario: MegaStar | puntos: 24
Usuario: MoDeR | puntos: 18
Usuario: Mario | puntos: 3
Usuario: Pedro | puntos: 24

*/

some(clave, callback(), clave_split)

Este metodo comprueba si al menos una propiedad del objeto(la base de datos) cumple con la condicion que se especificó en el callback. Es similar al Array.some

Argumentos

clave: La clave puede recibir dos tipos de valores, en el caso de que quieras buscar en las propiedades de un objeto especifico, puedes colocar el nombre del objeto. Si quieres buscar en las propiedades de un objeto anidado, puedes usar el . seguido del nombre del objeto anidado (el . es un signo por default, puedes cambiarlo en clave_split) Puedes usar false en caso de que directamente quieras buscar en las propiedades de una base de datos.
callback(valor_actual, clave_actual): Aqui deberas de poner la funcion que se ejecutara o evaluara sobre cada elemento iterado del objeto que especificaste en el argumento clave, el callback puede recibir 2 argumentos:

valor_actual (opcional): Aqui se mostrara el valor del elemento que se esta procesando en ese momento.
clave_actual (opcional): Aqui se mostrara la clave del elemento que se esta procesando en ese momento.

clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidadas en el argumento clave (por default es el .)

Retorna

Esto retornara true si al menos una propiedad del objeto cumple con la condicion del callback se cumple, de lo contrario retornara false.

Ejemplos


//ejemplo_1
const db = require("megadb");
let puntaje = new db.crearDB("puntajes")

puntaje.establecer('Mario', 2)
puntaje.establecer('Pedro', 4)
puntaje.establecer('Juan', 5)
puntaje.establecer('Jair', 6)

/* Estructura actual de la base de datos puntajes.json:

{
  "Mario": 2,
  "Pedro": 4,
  "Juan": 5,
  "Jair": 6
}

*/

let verificar = puntaje.some(false, (v) => v == 6)
if(verificar) {
  console.log("Un usuario tiene 6 puntos.")
}
else{
  console.log("Ningun usuario tiene 6 puntos.")
}

/*Esto da como resultado:
"Un usuario tiene 6 puntos"

*/


/////////////////////////////////////////////////////


//ejemplo_2
const db = require("megadb");
let users_lb = new db.crearDB("userspt")

let usuarios = {
  "user001": {
    "nombre": "MegaStar",   
    "puntos": 10
  },
  "user002": {  
    "nombre": "Juan",   
    "puntos": 4
  },
  "user003": {
    "nombre": "reDoM",   
    "puntos": 2
  }
}

users_lb.establecer('leaderboard', usuarios)

/* Estructura actual de la base de datos userspt.json:

{
  "leaderboard": {
    "user001": {
      "nombre": "MegaStar",   
      "puntos": 10
    },
    "user002": {  
      "nombre": "Juan",   
      "puntos": 4
    },
    "user003": {
      "nombre": "reDoM",   
      "puntos": 3
    }
  }
}

*/

console.log(users_lb.some("leaderboard", (v) => v.nombre == "MegaStar")) // retorna true
console.log(users_lb.some("leaderboard", (v) => v.nombre == "MoDeR")) // retorna false
console.log(users_lb.some("leaderboard", (v) => v.puntos > 5)) // retorna true

setIndex(clave, index, valor, clave_split)

Este metodo te permite remplazar un elemento especifico de un array a travez de su index (posicion).

Argumentos

clave: La clave puede recibir dos tipos de valores, en el caso de que quieras buscar en las propiedades de un objeto especifico, puedes colocar el nombre del objeto. Si quieres buscar en las propiedades de un objeto anidado, puedes usar el . seguido del nombre del objeto anidado (el . es un signo por default, puedes cambiarlo en clave_split) Puedes usar false en caso de que directamente quieras buscar en las propiedades de una base de datos.
index: Aqui deberas de poner el indice(index) del elemento que quieres remplazar en el array, esto es un numero.
valor: Aqui deberas de colocar el nuevo valor que tomará el elemento del indice(index) que especificaste en el parametro index
clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidadas en el argumento clave (por default es el .)

Retorna

Promesa con el array actualizado.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes obtenerlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos


//ejemplo_1
const db = require("megadb");
let mercado_db = new db.crearDB("mercado")

mercado_db.establecer('frutas', [
  "platano",
  "durazno",
  "manzana",
  "zanahoria"
])

/* Estructura actual de la base de datos mercado.json:
{
  "frutas": [
    "platano",
    "durazno",
    "manzana",
    "zanahoria"
  ]
}

*/

mercado_db.setIndex("frutas", 3, "piña") // retorna promesa: ["platano", "durazno", "manzana", "piña"]

delIndex(clave, index, clave_split)

Este metodo te permite remover un elemento especifico de un array a travez de su index (posicion).

Argumentos

clave: La clave puede recibir dos tipos de valores, en el caso de que quieras buscar en las propiedades de un objeto especifico, puedes colocar el nombre del objeto. Si quieres buscar en las propiedades de un objeto anidado, puedes usar el . seguido del nombre del objeto anidado (el . es un signo por default, puedes cambiarlo en clave_split) Puedes usar false en caso de que directamente quieras buscar en las propiedades de una base de datos.
index: Aqui deberas de poner el indice(index) del elemento que quieres remover del array, esto es un numero.
clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidadas en el argumento clave (por default es el .)

Retorna

Promesa con el array actualizado.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes obtenerlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos


//ejemplo_1
const db = require("megadb");
let mercado_db = new db.crearDB("mercado")

mercado_db.establecer('frutas', [
  "platano",
  "durazno",
  "manzana",
  "zanahoria"
])

/* Estructura actual de la base de datos mercado.json:
{
  "frutas": [
    "platano",
    "durazno",
    "manzana",
    "zanahoria"
  ]
}

*/

mercado_db.delIndex("frutas", 3) // retorna promesa: ["platano", "durazno", "manzana"]

/////////////////////////////////////////////////////


//ejemplo_2

const db = require("megadb");
let economy_db = new db.crearDB("economydb")

economy_db.establecer("usuarios", [
  {nombre: "megastar"},
  {nombre: "moder"},
  {nombre: "pedro"}
])

/* Estructura actual de la base de datos economydb.json:

{
  "usuarios": [
    {"nombre": "megastar"},
    {"nombre": "moder"},
    {"nombre": "pedro"}
  ]
}

*/
economy_db.obtener("usuarios").then(usuarios => {
  let index = usuarios.findIndex(u => u.nombre == "pedro")
  if(index != -1) {
    economy_db.delIndex("usuarios", index).then(nuevo_array => {
      console.log(nuevo_array)
    }).catch(error => console.log(error))
  }
  else{
    console.log("No hay ningun usuario con el nombre pedro.")
  }
}).catch(error => console.log(error))

/*
Resultado:

[
  {"nombre": "megastar"},
  {"nombre": "moder"}
]

findKey(clave, callback(), clave_split)

Este metodo retorna la clave de la primera propiedad que cumpla la condicion del callback, si no encuentra nada regresara undefined. Es similar al Array.findIndex, solo que en vez de retornar el indice, regresa la clave.

Argumentos

clave: La clave puede recibir dos tipos de valores, en el caso de que quieras buscar en las propiedades de un objeto especifico, puedes colocar el nombre del objeto. Si quieres buscar en las propiedades de un objeto anidado, puedes usar el . seguido del nombre del objeto anidado (el . es un signo por default, puedes cambiarlo en clave_split) Puedes usar false en caso de que directamente quieras buscar en las propiedades de una base de datos.
callback(valor_actual, clave_actual) : Aqui deberas de poner la funcion que se ejecutara o evaluara sobre cada elemento iterado del objeto que especificaste en el argumento clave, el callback puede recibir 2 argumentos:

valor_actual (opcional): Aqui se mostrara el valor del elemento que se esta procesando en ese momento.
clave_actual (opcional): Aqui se mostrara la clave del elemento que se esta procesando en ese momento.

clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades anidadas en el argumento clave (por default es el .)

Retorna

Esto retornara una promesa con la clave de la primera propiedad que cumpla la condicion del callback, de lo contrario retornara undefined.

Error

En caso de que ocurra un error, esto regresara un objeto con el error descriptivo (puedes obtenerlo con un .catch(error => )) Click aqui para ver los tipos de errores

Ejemplos


//ejemplo_1
const db = require("megadb");
let escuela = new db.crearDB("escuela")

escuela.establecer('Mario', {edad: 15, apellido: "garcia"})
escuela.establecer('Pedro', {edad: 12, apellido: "rojas"})
escuela.establecer('Juan', {edad: 10, apellido: "perez"})
escuela.establecer('Jair', {edad: 16, apellido: "gonzales"})

/* Estructura actual de la base de datos escuela.json:

{
  "Mario": {
    "edad: 15,
    "apellido: "garcia"
  },
  "Pedro": {
    "edad: 12,
    "apellido: "rojas"
  },
  "Juan": {
    "edad: 10,
    "apellido: "perez"
  },
  "Jair": {
    "edad: 16,
    "apellido: "gonzales"
  }
}

*/

escuela.findKey(false, (v) => v.edad == 16).then(alumno => { //v es el elemento que se esta procesando en ese momento

  //Ahora alumno debera de contener 'Jair'
    
  if(alumno == undefined) return console.log("Ningun alumno tiene 16 años")
  return console.log(`El alumno ${alumno} tiene 16 años!`)
}).catch(error => console.log(error))

//Esto da como resultado: "El alumno Jair tiene 16 años!"


/////////////////////////////////////////////////////


//ejemplo_2
const db = require("megadb");
let registros = new db.crearDB("registros")

let registrados = {
  "ID_1": {
    "username": "MegaStar",
    "password": "xxxxxxxx",
    "age": 20
  },
  "ID_2": {
    "username": "MoDeR",
    "password": "aaaaaaaa",
    "age": 19
  },
  "ID_3": {
    "username": "RatSageM",
    "password": "cccccccc",
    "age": 18
  }
}

registros.establecer('usuarios', registrados)

/* Estructura actual de la base de datos registros.json:

{
  "usuarios": {
    "ID_1": {
      "username": "MegaStar",
      "password": "xxxxxxxx",
      "edad": 20
    },
    "ID_2": {
      "username": "MoDeR",
      "password": "aaaaaaaa",
      "edad": 19
    },
    "ID_3": {
      "username": "RatSageM",
      "password": "cccccccc",
      "edad": 18
    }
  }
}

*/

registros.findKey("usuarios", (v) => v.username == "MegaStar").then(id => { //v es el elemento del objeto "usuarios" que se esta procesando en ese momento

  // Ahora id debera de contener 'ID_1'
   

  if(id == undefined) return console.log("No existe este usuario.")
  return console.log(`El ID del usuario MegaStar es: ${id}`)
}).catch(error => console.log(error))

//Esto da como resultado: "El ID del usuario MegaStar es: ID_1"

partition(clave, callback(), clave_split)

Este metodo divide un objeto(base de datos) en dos objetos donde el primer objeto contiene las propiedades que cumplan con la condicion del callback y el segundo objeto con las propiedades que no la condicion.

Argumentos

clave: La clave puede recibir dos tipos de valores, en el caso de que quieras buscar en las propiedades de un objeto especifico, puedes colocar el nombre del objeto. Si quieres buscar en las propiedades de un objeto anidado, puedes usar el . seguido del nombre del objeto anidado (el . es un signo por default, puedes cambiarlo en clave_split) Puedes usar false en caso de que directamente quieras buscar en las propiedades de una base de datos.
callback(valor_actual, clave_actual) : Aqui deberas de poner la funcion que se ejecutara o evaluara sobre cada elemento iterado del objeto que especificaste en el argumento clave, el callback puede recibir 2 argumentos:

valor_actual (opcional): Aqui se mostrara el valor del elemento que se esta procesando en ese momento.
clave_actual (opcional): Aqui se mostrara la clave del elemento que se esta procesando en ese momento.

clave_split (opcional): Este argumento es opcional, aqui puedes especificar el signo que se usara para acceder a propiedades a

Published

Vulnerabilities

Links

Maintainers

Keywords

Readme

Mejoras

Importante

Changelog

Constructor:

Metodos:

Instalacion:

Ejemplo del requerimiento del package: