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.
- 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.
v3.4.0
v3.3.0
v3.0.0
v2.8.0
v2.7.0
V2.6.0
V2.5.0
V2.4.0
V1.9.0
V1.7.0
V1.5.0
V1.4.0
npm install megadb --save
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.
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:
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.
### memoDBEl 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
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:
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
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
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
Retorna
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
Retorna
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
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
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
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
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
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
Retorna
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.
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.
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.
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.
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.
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.
Retorna
Esto retornara un Array con dos elementos, el primer elemento seria un objeto con las propiedades que cumplieron con la condicion del callback y el segundo elemento un objeto con las que no lo cumplieron.
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 clases_rpg = new db.crearDB("rpg")
clases_rpg.establecer('Mario', {hp: 200, clase: "enano"})
clases_rpg.establecer('MoDeR', {hp: 200, clase: "enano"})
clases_rpg.establecer('MegaStar', {hp: 100, clase: "elfo"})
clases_rpg.establecer('ratsagem', {hp: 100, clase: "elfo"})
/* Estructura actual de la base de datos rpg.json:
{
"Mario": {
"hp: 200,
"clase: "enano"
},
"Pedro": {
"hp: 200,
"clase: "enano"
},
"MegaStar": {
"hp: 100,
"clase: "elfo"
},
"ratsagem": {
"hp: 100,
"clase: "elfo"
}
}
*/
//Usando (async/await)
let [enanos, elfos] = await clases_rpg.partition(false, (v) => v.clase == 'enano')
console.log(`Usuarios de clase enano: ${Object.keys(enanos).join(", ")}\nUsuarios de clase elfo: ${Object.keys(elfos).join(", ")}`)
//usando then/catch
clases_rpg.partition(false, (v) => v.clase == 'enano').then(clases => { //v es el elemento que se esta procesando en ese momento
let [enanos, elfos] = clases
console.log(`Usuarios de clase enano: ${Object.keys(enanos).join(", ")}\nUsuarios de clase elfo: ${Object.keys(elfos).join(", ")}`)
}).catch(error => console.log(error))
/*Esto da como resultado:
Usuarios de clase enano: Mario, MoDeR
Usuarios de clase elfo: MegaStar, ratsagem
Si imprimimos:
- console.log(enanos)
{
Mario: { hp: 200, clase: 'enano' },
MoDeR: { hp: 200, clase: 'enano' }
}
- console.log(elfos)
{
MegaStar: { hp: 100, clase: 'elfo' },
ratsagem: { hp: 100, clase: 'elfo' }
}
*/
/////////////////////////////////////////////////////
//ejemplo_2
const db = require("megadb");
let clases_rpg = new db.crearDB("rpg")
let jugadores = {
"ID_1": {
"username": "MegaStar",
"hp": 100,
"clase": "elfo"
},
"ID_2": {
"username": "MoDeR",
"hp": 200,
"clase": "enano"
},
"ID_3": {
"username": "ratsagem",
"hp": 100,
"clase": "elfo"
}
}
clases_rpg.establecer('servidor1', jugadores)
/* Estructura actual de la base de datos rpg.json:
{
"servidor1": {
"ID_1": {
"username": "MegaStar",
"hp": 100,
"clase": "elfo"
},
"ID_2": {
"username": "MoDeR",
"hp": 200,
"clase": "enano"
},
"ID_3": {
"username": "ratsagem",
"hp": 100,
"clase": "elfo"
}
}
}
*/
//Usando (async/await)
let [enanos, elfos] = await clases_rpg.partition("servidor1", (v) => v.clase == 'enano')
console.log(`Usuarios de clase enano: ${enanos.map(e => e.username).join(", ")}\nUsuarios de clase elfo: ${elfos.map(e => e.username).join(", ")}`)
//usando then/catch
clases_rpg.partition("servidor1", (v) => v.clase == 'enano').then(clases => { //v es el elemento que se esta procesando en ese momento
let [enanos, elfos] = clases
console.log(`Usuarios de clase enano: ${enanos.map(e => e.username).join(", ")}\nUsuarios de clase elfo: ${elfos.map(e => e.username).join(", ")}`)
}).catch(error => console.log(error))
/*Esto da como resultado:
Usuarios de clase enano: MoDeR
Usuarios de clase elfo: MegaStar, ratsagem
Si imprimimos:
- console.log(enanos)
{
ID_2: { username: 'MoDeR', hp: 200, clase: 'enano' }
}
- console.log(elfos)
{
ID_1: { username: 'MegaStar', hp: 100, clase: 'elfo' },
ID_3: { username: 'ratsagem', hp: 100, clase: 'elfo' }
}
*/
convert_megadtbs()
Este metodo es especial, usalo solo cuando quieras adaptar tu base de datos del npm mega-dtbs al megadb. Para adaptar tu base de datos del mega-dtbs a megadb, debes de poner el nombre "mega_db" en el constructor crearDB. Asegurate de que el archivo mega_db.json se encuentre dentro de la carpeta mega_databases.
Argumentos
Ninguno.
Retorna
Nada.
Demostracion
Ejemplos
const db = require("megadb");
let megadb = new db.crearDB("mega_db")
megadb.convert_megadtbs()
Estructura del error:
Ejemplos
const db = require("megadb");
let paises = new db.crearDB("paises")
paises.establecer("norte", ["argentina", "brasil", "colombia"]) //retorna promesa: {norte: ["argentina", "brasil", "colombia"]}
paises.extract("norte", "bolivia").then(nuevos => {
console.log(nuevos)
}).catch(error => {
console.log(error)
})
//Esto retorna en el .catch()
const db = require('megadb');
let estadisticas = new db.crearDB('niveles');
let randomXP = Math.floor(Math.random() * 60) + 1;
if(!estadisticas.tiene('MegaStar')) {
estadisticas.establecer('MegaStar', {xp: 0, nivel: 1});
}
estadisticas.obtener('MegaStar').then(datos => {
if((randomXP + datos.xp) >= 50) {
estadisticas.establecer('MegaStar', {xp: 0, nivel: datos.nivel + 1}).then(nuevos => {
let nuevo_nivel = nuevos['MegaStar'].nivel
console.log(`MegaStar subio al nivel ${nuevo_nivel}!`)
}).catch(err => console.log(err))
}
else{
estadisticas.sumar('MegaStar.xp', randomXP)
}
}).catch(err => console.log(err))
/////////////////////////////////////////////////////
const db = require('megadb');
let escuela = new db.crearDB('alumnos');
escuela.establecer('MegaStar', {edad: 20, profesion: ['programador']});
escuela.establecer('MoDeR', {edad: 18, profesion: ['programador']});
escuela.establecer('RatSageM', {edad: 25, profesion: ['maestro']});
escuela.datos().then(alumnos => {
for(var alumno in alumnos) {
if(alumnos[alumno].profesion.includes('programador')) {
escuela.push(`${alumno}.profesion`, 'javascript');
continue;
}
escuela.eliminar(`${alumno}`)
}
})
//resultado final:
{
"MegaStar": {
"edad": 20,
"profesion": ["programador", "javascript"]
},
"MoDeR": {
"edad": 18,
"profesion": ["programador", "javascript"]
}
}
/////////////////////////////////////////////////////
const db = require('megadb');
let mercado_db = new db.crearDB('mercado');
let nombres = ['manzana', 'melocoton', 'sandia', 'lechuga']
mercado_db.establecer('frutas', nombres); //esto retorna {frutas: ['manzana', 'melocoton', 'sandia', 'lechuga']}
mercado_db.obtener('frutas').then(f => {
for(var x = 0; x < f.length; x++) {
if(f[x] == 'lechuga') {
mercado_db.extract('lechuga').then(nuevas_frutas => {
//esto retorna ['manzana', 'melocoton', 'sandia']
console.log(`La ${f[x]} no es una fruta, acabo de removerlo.`)
}).catch(error => {
console.log(`Ocurrio un error: ${error.type}, mensaje: ${error.mensaje}`)
})
break;
}
}
}).catch(error => {
console.log(error)
})
//resultado final:
{
"frutas": ["manzana", "melocoton", "sandia"]
}
/////////////////////////////////////////////////////
const db = require('megadb');
let economia_db = new db.crearDB('economia')
let usuarios = {
megastar: {monedas: 10, medallas: 15},
moder: {monedas: 50, medallas: 20},
ratsagem: {monedas: 25, medallas: 5}
}
economia_db.establecer('servidor.datos', usuarios)
economia_db.ordenar('servidor.datos', "monedas").then(nuevos => {
let ranking = []
for(var x = 0; x < nuevos.length; x++) {
ranking.push(`rank #${parseInt(x+1)} | usuario: ${nuevos[x].clave} | monedas: ${nuevos[x].valor.monedas} | medallas: ${nuevos[x].valor.medallas}\n`)
}
}).catch(error => console.log(error))
/*
resultado:
rank #1 | usuario: moder | monedas: 50 | medallas: 20
rank #2 | usuario: ratsagem | monedas: 25 | medallas: 5
rank #3 | usuario: megastar | monedas: 10 | medallas: 20
*/
/////////////////////////////////////////////////////
const db = require('megadb');
let login_db = new db.crearDB('login')
let registered_users = {
"Mario": "password1",
"MegaStar": "password2",
"MoDeR": "password3",
"RatSageM": "password4"
}
login_db.establecer('usuarios', registered_users)
/*
Estructura actual de la base de datos login.json:
{
"usuarios": {
"Mario": "password1",
"MegaStar": "password2",
"MoDeR": "password3",
"RatSageM": "password4"
}
}
*/
login_db.keys('usuarios').then(users => {
console.log(`Nombres de los usuarios registrados: ${users.join(", ")}`)
}).catch(error => console.log(error))
//resultado: "Nombres de los usuarios registrados: Mario, MegaStar, MoDeR, RatSageM"
FAQs
base de datos usando JSON
The npm package megadb receives a total of 130 weekly downloads. As such, megadb popularity was classified as not popular.
We found that megadb demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
In this segment of the Risky Business podcast, Feross Aboukhadijeh and Patrick Gray discuss the challenges of tracking malware discovered in open source softare.
Research
Security News
A threat actor's playbook for exploiting the npm ecosystem was exposed on the dark web, detailing how to build a blockchain-powered botnet.
Security News
NVD’s backlog surpasses 20,000 CVEs as analysis slows and NIST announces new system updates to address ongoing delays.