megadb - npm Package Compare versions

Comparing version 1.9.0 to 2.4.0

index.js

@@ -170,3 +170,3 @@ const fs = require('graceful-fs'),
           if(err) throw new Error(`[ERROR] No se pudo crear la carpeta mega_databases donde se almacenaran las base de datos, error: ${err}`)
-          console.log(`[CREANDO DIRECTORIO] Acaba de crearse la carpeta mega_databases, en esta carpeta ${sub_directory != false ? "se creara tu sub directorio" : "en esta carpeta se almacenaran tus base de datos"}.`)
+          console.log(`[CREANDO DIRECTORIO] Acaba de crearse la carpeta mega_databases, en esta carpeta ${sub_directory != false ? "se creara tu sub directorio" : "se almacenaran tus base de datos"}.`)
         })
@@ -253,2 +253,5 @@ }
   - size
+  - find
+  - map
+  - filter
 
@@ -874,2 +877,121 @@ */
 
+function find(clave, callback, split_object) { //retorna valor
+  if(!split_object) split_object = "."
+  if(typeof split_object != "string") throw new Error(`[ERROR] El signo que se usara para la clave debe ser un string`)
+  if(!callback || typeof callback != "function") throw new Error('[ERROR] El segundo argumento debe ser un callback (funcion)')
+  if(clave === false) {
+    if(Object.keys(global_object[this.database_name]).length <= 0) return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `Actualmente no hay ninguna propiedad`))
+    for(var key in global_object[this.database_name]) {
+      if(callback(global_object[this.database_name][key], key)) return Promise.resolve(global_object[this.database_name][key])
+    }
+    return Promise.resolve(undefined)
+  }
+  check_path_object(clave, split_object)
+
+  var split_object = clave.split(split_object)
+  var object_data = global_object[this.database_name]
+  for(var x in split_object) {
+    var key = split_object[x]
+    if(typeof object_data[key] != "undefined") {
+      if(x == split_object.length-1) {
+        for(var key2 in object_data[key]) {
+          if(callback(object_data[key][key2], key2)) return Promise.resolve(object_data[key][key2])
+        }
+        return Promise.resolve(undefined)
+      }
+      object_data = object_data[key]
+      continue
+    }
+    return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `No se encontro la propiedad ${key}`))
+  }
+}
+
+
+//--------------------------------------------------------------------------------------\\
+//---------------------------------------------------------------------------------------\\
+
+
+function filter(clave, callback, split_object) { //retorna un nuevo objeto con los elementos que cumplan la condicion del callback, similar al <array>.filter
+  if(!split_object) split_object = "."
+  if(typeof split_object != "string") throw new Error(`[ERROR] El signo que se usara para la clave debe ser un string`)
+  if(!callback || typeof callback != "function") throw new Error('[ERROR] El segundo argumento debe ser un callback (funcion)')
+
+  let filter_array = {}
+
+  if(clave === false) {
+    if(Object.keys(global_object[this.database_name]).length <= 0) return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `Actualmente no hay ninguna propiedad`))
+
+    for(var key in global_object[this.database_name]) {
+      if(callback(global_object[this.database_name][key], key)) filter_array[key] = global_object[this.database_name][key]
+    }
+
+    if(Object.keys(filter_array).length <= 0) return Promise.resolve(undefined)
+    return Promise.resolve(filter_array)
+  }
+  check_path_object(clave, split_object)
+
+  var split_object = clave.split(split_object)
+  var object_data = global_object[this.database_name]
+  for(var x in split_object) {
+    var key = split_object[x]
+    if(typeof object_data[key] != "undefined") {
+      if(x == split_object.length-1) {
+        for(var key2 in object_data[key]) {
+          if(callback(object_data[key][key2], key2)) filter_array[key2] = object_data[key][key2]
+        }
+
+        if(Object.keys(filter_array).length <= 0) return Promise.resolve(undefined)
+        return Promise.resolve(filter_array)
+      }
+      object_data = object_data[key]
+      continue
+    }
+    return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `No se encontro la propiedad ${key}`))
+  }
+}
+
+
+//--------------------------------------------------------------------------------------\\
+//---------------------------------------------------------------------------------------\\
+
+
+function map(clave, callback, split_object) { //retorna un array con los resultados que se especifico en el callback, similar al <array>.map
+  if(!split_object) split_object = "."
+  if(typeof split_object != "string") throw new Error(`[ERROR] El signo que se usara para la clave debe ser un string`)
+  if(!callback || typeof callback != "function") throw new Error('[ERROR] El segundo argumento debe ser un callback (funcion)')
+
+  if(clave === false) {
+    if(Object.keys(global_object[this.database_name]).length <= 0) return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `Actualmente no hay ninguna propiedad`))
+    let map_array = new Array()
+
+    for(var key in global_object[this.database_name]) map_array.push(callback(global_object[this.database_name][key], key))
+
+    return Promise.resolve(map_array)
+  }
+  check_path_object(clave, split_object)
+
+  var split_object = clave.split(split_object)
+  var object_data = global_object[this.database_name]
+  for(var x in split_object) {
+    var key = split_object[x]
+    if(typeof object_data[key] != "undefined") {
+      if(x == split_object.length-1) {
+        let map_array = new Array()
+
+        for(var key2 in object_data[key]) map_array.push(callback(object_data[key][key2], key2))
+
+        return Promise.resolve(map_array)
+      }
+      object_data = object_data[key]
+      continue
+    }
+    return Promise.reject(ErrorDesc("PROPIEDAD NO EXISTENTE", `No se encontro la propiedad ${key}`))
+  }
+}
+
+
+//--------------------------------------------------------------------------------------\\
+//---------------------------------------------------------------------------------------\\
+
+
 crearDB.prototype.existeDB = existeDB
@@ -892,1 +1014,4 @@ crearDB.prototype.establecer = establecer
 crearDB.prototype.size = size
+crearDB.prototype.find = find
+crearDB.prototype.filter = filter
+crearDB.prototype.map = map

package.json

 {
   "name": "megadb",
-  "version": "1.9.0",
+  "version": "2.4.0",
   "description": "base de datos usando JSON",
@@ -5,0 +5,0 @@ "main": "index.js",

README.md

@@ -22,2 +22,5 @@ ```
 
+V2.4.0
+* Se agrego 3 nuevos metodos (find, map, filter)
+
 V1.9.0
@@ -56,2 +59,5 @@ * Se agrego 3 nuevos metodos (size, keys, values)
 * [existeDB](#existeDB)
+* [find](#find)
+* [filter](#filter)
+* [map](#map)
 * [convert_megadtbs](#convert_megadtbs)
@@ -421,2 +427,3 @@
 
+
 <a name="extract" />
@@ -476,2 +483,3 @@ ### extract
 
+
 <a name="sumar" />
@@ -1185,2 +1193,501 @@ ### sumar
 
+
+<a name="find" />
+### find
+
+```js
+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__
+
+1. 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 objecto. 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.
+
+2. 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.
+```
+
+3. 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](#Errores)
+
+__Ejemplos__
+
+```js
+
+//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!`)
+})
+
+//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}`)
+})
+
+//Esto da como resultado: "Datos, username: MegaStar, contraseña: xxxxxxxx, edad: 20"
+```
+
+
+<a name="filter" />
+### filter
+
+```js
+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 **undefined**.
+Es similar al **Array.filter** solo que en vez de regresar un nuevo array, regresa un nuevo objeto.
+
+__Argumentos__
+
+1. 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 objecto. 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.
+
+2. 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.
+```
+
+3. 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 **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](#Errores)
+
+__Ejemplos__
+
+```js
+
+//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(nuevos == undefined) 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(usuarios == undefined) 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
+
+*/
+```
+
+
+<a name="map" />
+### map
+
+```js
+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__
+
+1. 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 objecto. 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.
+
+2. 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.
+```
+
+3. 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 especifico 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](#Errores)
+
+__Ejemplos__
+
+```js
+
+//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
+
+*/
+```
+
+
 <a name="convert_megadtbs" />
@@ -1187,0 +1694,0 @@ ### convert_megadtbs

No alert changes

Improved metrics

Total package byte prevSize

95827

increased by24.67%

Lines of code

805

increased by14.18%

Number of lines in readme file

1914

increased by36.03%

No dependency changes