LEEME.md

like-ar

Using objects like arrays with map, filter, forEach and others coming soon.

idioma: también disponible en:

Instalación

$ npm install like-ar

Uso

La función LikeAr envuelve un objeto de modo que puedan usarse un conjunto conocido de funciones diseñadas para correr sobre arreglos: forEach, map, filter y join. Similarmente a lo que ocurre con arreglos estas funciones reciben una función que se ejecuta para cada elemento del objeto, esa función recibe el valor, la clave y el objeto original.

var {LikeAr} = require('like-ar');

var object={
    lastName:'Perez',
    firstName:'Diego',
    phone:'+45-11-2222-3333'
}

LikeAr(object).forEach(function(value, attrName, object, position){
    console.log(position+'.',attrName,':',value);
});

console.log(
    LikeAr(object).filter(function(value, attrName){
        return attrName.contains('Name');
    }).map(function(value,attrName){
        return attrName+':'+value
    }).join(', ')
);

var objectUpperCase=LikeAr(object).map(v=>v.toUpperCase());

/* objectUpperCase = 
var object={
    lastName:'PEREZ',
    firstName:'DIEGO',
    phone:'+45-11-2222-3333'
}
*/

API

likeAr(object)

Devuelve el objeto encadenable. Ese objeto tiene los siguientes métodos:

función	valor devuelto
forEach(cb, this)	undefined
map(cb, this)	objeto encadenable con las mismas claves y los valores mapeados
filter(cb, this)	objeto encadenable con los mismas claves y valores para los que la función callback retornó true
join(separator)	texto con los valores unidos por el separador
array()	arreglo conteniendo solo los valores
keys()	arreglo conteniendo solo las claves
plain()	devuelve un objeto plano (donde ya no se puede llamar a forEach, map, filter, etc)

Todas las funciones callback (cb) reciben como parámetro: valor, clave, objeto original y posición (numérica comenzando con 0).

LikeAr(object).build(cb(value, key))

Construye un objeto nuevo con las claves cambiadas. La función cb debe devolver el elemento como un objeto de un solo campo {k: v} que se usará para componer el resultado final.

var pairs=[{field:'lastName', value:'Perez'}, {field:'firstName', value:'Diego'}];

console.log(LikeAr(pairs).build(funciton(pair){ return {[pair.field]: pair.value}; ));
// {lastName: "Perez", firstName: "Diego"}

var toJoin=[{lastName:'Perez'}, {firstName:'Diego'}];

console.log(LikeAr(toJoin).build(funciton(objectWithOneKey){ return objectWithOneKey; ));
// {lastName: "Perez", firstName: "Diego"}

LikeAr.toPlainObject(array [,keyName [,valueName]])

LikeAr.toPlainObject(arrayOfKeys, arrayOfValues)

Construye un objeto común (no encadenable) a partir de un arreglo de pares (o de un par de arreglos) de claves y valores.

Parámetros predeterminados: si no se especifica keyName se usan 0 y 1 y se supone que los pares vienen en un arreglo. Si se especifica keyName el valor predeterminado de valueName es "value".

var {LikeAr} = require('like-ar');

var pairs=[['lastName', 'Perez'], ['firstName', 'Diego']];

console.log(LikeAr.toPlainObject(pairs));

var pairs=[{field:'lastName', value:'Perez'}, {field:'firstName', value:'Diego'}];

console.log(LikeAr.toPlainObject(pairs, 'field'));

LikeAr.createIndex(array:T[], keyName:string): Record<string, T>

Construye un objeto común que será índice de los elementos de un arreglo existente. Cada valor del objeto apunta a un elemento del arreglo existente.

var {LikeAr} = require('like-ar');

var persons=[{name:'Diego', lastName:'Rivera', age:30}, {name:'Frida', lastName:'Kahlo'}];

var idxPersons=LikeAr.createIndex(persons, 'lastName');

idxPersons.Kahlo.age=20;

console.log(persons[1].age); // 20

LikeAr.createIndex(array:T[], getKey:T => string): Record<string, T>

Construye un objeto común que será índice de los elementos de un arreglo existente. Cada valor del objeto apunta a un elemento del arreglo existente. El índice es calculado por la función getKey

var {LikeAr} = require('like-ar');

var persons=[{name:'Diego', lastName:'Rivera', age:30}, {name:'Frida', lastName:'Kahlo'}];

var idxPersons=LikeAr.createIndex(persons, (p) => p.name + p.lastName);

idxPersons.FridaKahlo.age=20;

console.log(persons[1].age); // 20

LikeAr.iterator(arrayOrObject: T[] | Record<K,T>): Iterator<T>

Devuelve un Iterator<T> a partir de un Array<T> o un Record<K,T>. Si el parámetro es un arreglo se devuelve el mismo arreglo, si es un objeto se devuelve un iterador a los valores.

var {iterator} = require('like-ar');

function showValues(arrayOrObject: any[] | Record<any, any>){
    for (var value of iterator(arrayOrObject)) {
        console.log(value)
    }
}

LikeAr<K,T>(object:Record<K,Promise<T>>).awaitAll(): Promise<Record<K,T>>

Corre las promesas en paralelo, cuando todas terminan devuelve un objeto con las mismas claves y la resolución de cada promesa. Si alguna de las promesas falla la función falla con la primera sin esperar la finalización del resto.

var likear = require('like-ar').strict;

var sqls = {
    persons: 'select * from person',
    mascots: 'select * from mascot'
}

var data = await likear(sqls).map(async sql => db.query(sql)).awaitAll();

console.log(data);

LikeAr.empty(arrayOrObject: T[] | Record<K,T> | null): boolean

Devuelve false si el arreglo o el objeto tiene al menos un elemento. Devuelve true si está vacío (si el arreglo es = [] o el objeto = {} ó null)

var {iterator, emtpy} = require('like-ar');

function showValues(arrayOrObject: any[] | Record<any, any> | null){
    if (empty(arrayOrObject)) {
        Console.log('EMPTY!')
    }
    for (var value of iterator(arrayOrObject)) {
        console.log(value)
    }
}

Licencia

MIT