Ct-js-utils NPM

ct-js-utils

A javascript utils by CT.

How to get

npm install --save ct-js-utils

APIs

flat2DList(list, getList)
isOk(value)
getValue(defaultValue, arg1, ..., argN)
groupByKey(listOrObj, getKeyFunc, ignoreFunctions)
reduceByKey(listOrObj, getKeyFunc, ignoreFunctions, reduceFunc, defaultValue)
getNewId(length, characters)
objectMap(obj, mapFunc, ignoreFunctions)
objectReduce(obj, reduceFunc, defaultValue, ignoreFunctions)
countByKey(listOrObj, getKeyFunc, ignoreFunctions)
getUniqueKeysAfterCount(listOrObj, getKeyFunc, ignoreFunctions)
increment(value, diff)
pickOne(value, otherwise, whiteList, blackList)
randPosInt(listSize)
randIndex(listOrObj, ignoreFunctions)
randPick(listOrObj, ignoreFunctions)

flat2DList(list, getList)

Convert 2D list into 1D.

let list = [[1], [2, 2], [3, 3, 3]];
expect(util.flat2DList(list)).to.deep.equal([1, 2, 2, 3, 3, 3]);

let objList = [{ list: ['a'] }, { list: ['a', 'b'] }, { list: ['a', 'c', 'd'] }];
expect(util.flat2DList(objList, obj=> obj.list))
    .to.deep.equal(['a', 'a', 'b', 'a', 'c', 'd']);

groupByKey(listOrObj, getKeyFunc, ignoreFunctions)

Group obj to an array base on the key(getKeyFunc(obj)).

let list = [1,2,3,4,5];
function getKey(num){
    return num % 2;
}
let result = util.groupByKey(list, getKey);
expect(result[0]).to.deep.equal([2,4]);
expect(result[1]).to.deep.equal([1,3,5]);

reduceByKey(listOrObj, getKeyFunc, ignoreFunctions, reduceFunc, defaultValue)

Reduce obj to an array base on the key(getKeyFunc(obj)).

let list = [1,2,3,4,5];
function getKey(num){
    return num % 2;
}
let result = util.reduceByKey(list, getKey, true, (a,b)=> a+b, 5);
expect(result[0]).to.equal(5 + 2 + 4);
expect(result[1]).to.equal(5 + 1 + 3 + 5);

getNewId(length, characters)

Get a string with certain length and random chose from a-z, A-Z, 0-9 in default.

let newId = util.getNewId(500);
expect(newId.length).to.equal(500);
//each character in this string is a-z, A-Z, 0-9
expect(newId.search(/[^a-zA-Z0-9]/)).to.equal(-1);
//advanced usage, specified character list
newId = util.getNewId(500, '!@#$%^&*()');
expect(newId.length).to.equal(500);
expect(newId.search(/[!@#$%^&]/)).to.not.equal(-1);

objectMap(obj, mapFunc, ignoreFunctions)

A map function of Object. Ignore functions in the object in default.

let obj = {
    a: 1,
    b: 2,
    c: 3,
    test: function(){}
};
function map(value){
    return value * 2;
}
expect(util.objectMap(obj, map)).to.deep.equal({
    a: 2, b:4, c:6
});

objectReduce(obj, reduceFunc, defaultValue, ignoreFunctions)

A reduce function of Object. Ignore functions in the object in default. defaultValue, ignoreFunctions are optional.

let obj = {
    a: 1,
    b: 2,
    c: 3
};
function reduce(prev, current){
    return prev + current;
}
function reduce2(prev, current){
    return '' + prev + current;
}
expect(util.objectReduce(obj, reduce, 0)).to.equal(6);
expect(util.objectReduce(obj, reduce, '0')).to.equal('0123');
expect(util.objectReduce(obj, reduce2)).to.equal('123');

countByKey(listOrObj, getKeyFunc, ignoreFunctions)

Get a object which contain same value(String) after getKeyFunc.

default getKeyFunc getKeyFunc = function(key){ return key;};

let arr = [1,2,3,1,1];
let obj = util.countByKey(arr);
expect(obj[1]).to.equal(3);
expect(obj[2]).to.equal(1);
expect(obj[3]).to.equal(1);
expect(obj[5]).to.be.an('undefined');
//all the key is treat as string value
arr.push('1');
arr.push('1');
expect(obj[1]).to.equal(5);

function getKey(key){
    if(key < 2){
        return '<2';
    }else{
        return '>=2';
    }
}
//with getKey function, [1,2,3,1,1,'1','1']
obj = util.countByKey(arr, getKey);
expect(obj['<2']).to.equal(5);
expect(obj['>=2']).to.equal(2);

//input is an object
let input = {
    a:1,
    b:1,
    c:2,
    1:3,
    'test': '1'
};
obj = util.countByKey(input);
expect(obj['1']).to.equal(3);
expect(obj['2']).to.equal(1);
expect(obj['3']).to.equal(1);
expect(obj.test).to.be.an('undefined');

getUniqueKeysAfterCount(listOrObj, getKeyFunc, ignoreFunctions)

Get an unique key array after countByKey

let arr = [1,2,3,1,1,'1','1'];
console.log(util.getUniqueKeysAfterCount(arr)); //['1','2','3']

increment(value, diff)

Get a result after value + diff (default 1)

let undef;
expect(util.increment(undef)).to.equal(1);
expect(util.increment(null)).to.equal(1);
expect(util.increment(2)).to.equal(3);
expect(util.increment(-5, -1)).to.equal(-6);
expect(util.increment(-5, 0)).to.equal(-5);
expect(util.increment(1, '')).to.equal('1');

pickOne(value, otherwise, whiteList, blackList)

Pick value or otherwise by whiteList and blackList. whiteList can be [0, '', null, undefiend] (which put into if will go to else) If value is in blackList, will return otherwise.

let undef;
expect(util.pickOne('abc', 1)).to.equal('abc');
//whiteList
expect(util.pickOne(undef, 1)).to.equal(1);
expect(util.pickOne(null, 1)).to.equal(1);
expect(util.pickOne(null, 1, [null])).to.be.a('null');
expect(util.pickOne(undef, 1, [undef])).to.be.a('undefined');
//blackList
expect(util.pickOne(2, 1)).to.equal(2);
expect(util.pickOne(2, 1, null, [2,4,6])).to.equal(1);

isOk(value)

Return false only when value is null or undefined.

let undef;
expect(util.isOk(undef)).to.equal(false);
expect(util.isOk(null)).to.equal(false);
expect(util.isOk(1)).to.equal(true);
expect(util.isOk('abc')).to.equal(true);
expect(util.isOk(false)).to.equal(true);

getValue(defaultValue, arg1, ..., argN)

Avoid null or undefined from 'a'-'f' test'a'.get('b')'c'.func2('e')'f'.
If it is null or undefined in the path, will get defaultValue. Simplify it to

getValue(DEFAULT_V, test, 'a', prev=>prev.get('b'), 'c', 'd', prev=> prev.func2('e'), 'f')

If arg is function, will treat it as a getter from prev result. Otherwise, as a key to get related value from object(array).

const getValue = util.getValue;
let undef;

//obj[k1][k2], obj is undefined, get default
let t0 = getValue('qq', undef, 'a');
expect(t0).to.equal('qq');

//test, test is not null and not undefined, get test itself
let test = {};
let t10 = getValue(1, test);
expect(t10).to.deep.equal({});

//test[k1][k2], test[k1] is undefined, get default
let t1 = getValue(1, test, 'a', 'b');
expect(t1).to.equal(1);

//one level retreive
//test[k1] is exist and neither undefined nor null, get test[k1]
test.a = { b: {} };
let t11 = getValue(1, test, 'a');
expect(t11).to.deep.equal(t11, { b: {} });

//2 level retreive
//test[k1][k2] is exist and neither undefined nor null, get test[k1][k2]
let t2 = getValue(1, test, 'a', 'b');
expect(t2).to.deep.equal({});

//multi level(3) retreive
//test[k1][k2][k3] is exist, get test[k1][k2][k3]
const ABC = {
    value: 5,
    get: function (arg) {
        return this.value + arg;
    },
};
test.a.b.c = ABC;
let t3 = getValue(1, test, 'a', 'b', 'c');
expect(t3.value).to.equal(5);
expect(t3).to.deep.equal(ABC);

//test[k1][k2][k3].get(100)
let t4 = getValue(1, test, 'a', 'b', 'c', function (prevResult) {
    return prevResult.get(100);
});

expect(t4).to.equal(105);

//only set default, return default
let t5 = getValue('onlyDefault');
expect(t5).to.equal('onlyDefault');

function getObj(key) {
    let obj = {};
    obj.key = key;
    obj.get = getObj;
    obj.null = null;
    return obj;
}

let testObj = getObj('begin');

//testObj.get(k1).get(k2),  test.get(k1) is null, get default
let t6 = getValue('hi', testObj, obj=> obj.null, obj=> obj.get('hi'));
expect(t6).to.equal('hi');

//testObj.get(k1).get(k2),  return test.get(k1).get(k2)
let t7 = getValue('t7', testObj, obj=> obj.get('a'), obj=> obj.get('ab'));
expect(t7).to.deep.equal(getObj('ab'));

//test[k1].get[k2]
test.k1 = getObj('hi');
let t8 = getValue('t8', test, 'k1', obj=> obj.get('t8'));
expect(t8).to.deep.equal(getObj('t8'));

randPosInt(listSize)

If listSize is not > 0, return -1, Otherwise return 0 ~ listSize -1;

let undef;
expect(util.randPosInt(null)).to.equal(-1);
expect(util.randPosInt(undef)).to.equal(-1);
expect(util.randPosInt(0)).to.equal(-1);

let size = 100;
let result = util.randPosInt(size);
expect(result).to.be.at.most(size - 1);
expect(result).to.be.at.least(0);

//is an Integer
expect(result).to.equal(Math.floor(result));
expect(typeof result).to.equal('number');

randIndex(listOrObj, ignoreFunctions)

return the index of list or obj, ignoreFunctions is false in default.

let list = [1, 2, 3, 4, 5];
let obj = {
    a: list[0],
    b: list[1],
    c: list[2],
    d: list[3],
    e: list[4],
};

let size = list.length;

//test list
let index = util.randIndex(list);
expect(index).to.be.at.most(size - 1);
expect(index).to.be.at.least(0);

//is an Integer
expect(index).to.be.a('string');
expect(index == Math.floor(index)).to.be.true;

//test object
let result = util.randIndex(obj);
expect(result.length).to.equal(1);
expect(result).to.be.oneOf(Object.keys(obj));

obj.f = function () {};

result = util.randIndex(obj, false);
expect(result.length).to.equal(1);
expect(result).to.be.oneOf(Object.keys(obj));

result = util.randIndex(obj, true);
expect(result.length).to.equal(1);
expect(result).to.not.equal('f');

randPick(listOrObj, ignoreFunctions)

return one element from list or obj, ignoreFunctions is false in default

let list = [1, 2, 3, 4, 5];
let obj = {
    a: list[0],
    b: list[1],
    c: list[2],
    d: list[3],
    e: list[4],
};

let size = list.length;

//test list
let result = util.randPick(list);
expect(result).to.be.oneOf(list);

//test object
result = util.randPick(obj);
expect(result).to.be.oneOf(list);

obj.f = function () {};

//test object with function element
result = util.randPick(obj, false);
expect(result).to.be.oneOf(Object.keys(obj).map(key=> obj[key]));

let targets = Object.keys(obj).filter(key=> key !== 'f').map(key=> obj[key]);
let result1 = util.randPick(obj);
let result2 = util.randPick(obj, true);

expect(result1).to.be.oneOf(targets);
expect(result2).to.be.oneOf(targets);