tuyo

Provides additional, enhanced & unified operations for various data types in JavaScript.

Install

npm i tuyo

Usage

import tuyo from 'tuyo'

// 0.1 + 0.2 = 0.30000000000000004
const number = 0.1
tuyo(number).plus(0.2).value // 0.3
tuyo(number).plus(0.2).minus(0.2).times(100).div(100).toFixed(2).value // 0.10

const string = 'abc'
const _string = tuyo(string)
_string.type // string
_string.isString // true
_string.length // 3
_string.each((value, index, valueType, data) => {
    console.log(value, index, valueType, data)
})
// 'a' 0 'string' 'abc'
// 'b' 1 'string' 'abc'
// 'c' 2 'string' 'abc'

_string.each((value, index, valueType, data) => {
    console.log(value, index, valueType, data)
}, 'reverse')
// 'c' 2 'string' 'abc'
// 'b' 1 'string' 'abc'
// 'a' 0 'string' 'abc'

const array = [10, 20, [1, 2, 3], 2, 1]
const _array = tuyo(array)
// typeof array === 'object'
_array.type // array
_array.isArray // true
_array.length // 3

// array.indexOf([1, 2, 3]) === -1
_array.indexOf([1, 2, 3]) // 2
_array.indexOf([1, 3, 2]) // 2
_array.has([1, 2, 3]) // true
_array.has([1, 3, 1]) // true

// [10, 20, [1, 2, 3], 2, 1] === [10, 20, [1, 2, 3], 2, 1]  ==>  false
_array.isSame([10, 20, [1, 2, 3], 2, 1]) // true
_array.isSame([1, 2, [1, 2, 3], 20, 10]) // true
_array.isSame([1, 2, [3, 2, 1], 10, 20]) // true

_array.isSameType([]) // true
_array.isSameType({}) // false

// sort [number|string|array|object|set|map...]  See the details in 'Utils' below
const arr = [20, 'computer', '15', 'amazon', 1, '2', 'zoom' , 10, '15', '4', 'apple'];
const _array = tuyo(arr)
_array.sort()
// _array.value ==> [1, 10, 20, '2', '4', '15', '150', 'amazon', 'apple', 'computer', 'zoom']
_array.sort((a, b) => b - a)
// _array.value ==> ['zoom', 'computer', 'apple', 'amazon', '150', '15', '4', '2', 20, 10, 1]
_array.sort((a, b) => b - a, {
  'number': 0,
  'string': 1
})
// _array.value ==> [20, 10, 1, '150', '15', '4', '2', 'zoom', 'computer', 'apple', 'amazon']

// if use array.sort()
// arr.sort((a, b) => a - b)
// arr === > ????  Who knows what the result will be...

// sort and each
_array.each((value, index, valueType, data) => {
  console.log(value, index, valueType, data)
}, (a, b) => a - b)
// 1 0 'number' [10, 20, [1, 2, 3], 2, 1]
// 2 1 'number' [10, 20, [1, 2, 3], 2, 1]
// 10 2 'number' [10, 20, [1, 2, 3], 2, 1]
// 20 3 'number' [10, 20, [1, 2, 3], 2, 1]
// [1, 2, 3] 4 'array' [10, 20, [1, 2, 3], 2, 1]

// continue
_array.each((value, index, valueType, data) => {
    if(value === 2) return 'continue'
    console.log(value)
}, (a, b) => a - b)
// 1
// 10
// 20
// [1, 2, 3]

// break
_array.each((value, index, valueType, data) => {
    if(value === 2) return false
    console.log(value)
}, (a, b) => a - b)
// 1

const res = _array.reduce((prev, curr, currIndex, currType, data) => {
  return currType === 'number' ? prev + curr : prev
})
// res === 33

// iterator
while(!_array.iterator.isDone()) {
  const raw = _array.iterator.next()
  console.log(raw)
}
// { done: false, key: 0, value: 10 }
// { done: false, key: 1, value: 20 }
// { done: false, key: 2, value: [1, 2, 3] }
// { done: false, key: 3, value: 2 }
// { done: true, key: 4, value: 1 }

const object = {a: 1, b:2, c: 3}
// typeof object === 'object'
tuyo(object).type // array
tuyo(object).isObject // true
tuyo(object).length // 3

tuyo(object).each((value, key, valueType, data) => {
  console.log(value, key, valueType, data)
})
// 1 'a' 'number' {a: 1, b: 2, c: 3}
// 2 'b' 'number' {a: 1, b: 2, c: 3}
// 3 'c' 'number' {a: 1, b: 2, c: 3}

// reduce..
// isSame..
// has..
// iterator...

const set = new Set([1, 2, 3])
// typeof set === 'object'
tuyo(set).type // set
tuyo(set).isSet // true
tuyo(set).length // 3
tuyo(set).each((value, key, valueType, data) => {
  console.log(value, key, valueType, data)
})

// reduce..
// isSame..
// has..
// iterator...

const map = new Map([['a', 1], ['b'], 2], ['c', 3])
// typeof object === 'object'
tuyo(map).type // map
tuyo(map).isMap // true
tuyo(map).length // 3
tuyo(set).each((value, key, valueType, data) => {
  console.log(value, key, valueType, data)
})

// reduce..
// isSame..
// has..
// iterator...

Api

const data = [1,2,3]
const _data = tuyo(data)

// only getter
_data.value // [1, 2, 3]
// only getter
_data.length // 3
// only getter
_data.type // array
// _data.is`Type` 
_data.isArray // true

_data.iterator.isDone() // false
_data.iterator.next() // { done: false, key: 0, value: 1 }

_data.has(1) // true
_data.indexOf(1) // 0
_data.isSameType([]) // true
_data.isSame([3,2,1]) // true
_data.sort((a, b) => b - a) // _data.value == > [3,2,1]

const data = 0.1
data.plus(1).minus(1).times(1).div(1).toFixed(2).value // 0.10

Utils

import {
    isUndefined,
    isNull,
    isBoolean,
    isNumber,
    isString,
    isSymbol,
    isArray,
    isObject,
    isSet,
    isMap,
    isWeakSet,
    isWeakMap,
    isFunction,
    isDate,
    isArguments,
    isRegExp,
    isHTMLCollection,
    getType,
    isBaseType,
    isSameType,
    isSame,
    keys,
    values,
    alphabetIndex,
    plus,
    minus,
    times,
    div,
    toFixed,
    has,
    indexOf,
    sort,
    each,
    reduce,
} from 'tuyo/utils'

/**
 * @param {*} value The value to check.
 * @returns {boolean}
 */
isUndefined(undefined) // true
isNull(null) // true
isBoolean(true) // true
isNumber(123) // true
isNumber(NaN) // false
isString('abc') // true
isSymbol(Symbol()) // true
isArray([]) // true
isObject({}) // true
isSet(new Set()) // true
isMap(new Map()) // true
isWeakSet(new WeakSet()) // true
isWeakMap(new WeakMap()) // true
isFunction(function () {}) // true
// ...
// isHTMLCollection()

/**
 * @param {*} value.
 * @returns {string} Object.prototype.toString() [object ${type}] . Except 'NaN'
 */
getType({} - {}) // 'NaN'
// typeof ({} - {})  ==>  number

/**
 * @param {*} value.
 * @returns {boolean} Returns `true` if type in ['number', 'string', 'boolean', 'symbol', 'null', 'undefined'], else `false`.
 */
isBaseType(100) // true
isBaseType([]) // false

/**
 * @param {*} value1.
 * @param {*} value2.
 * @returns {boolean} Returns `true` if 'value1' and 'value2' are of the same type, else `false`.
 */
isSameType([], [1]) // true

/**
 * @param {*} value1.
 * @param {*} value2.
 * @returns {boolean} Returns `true` if 'value1' and 'value2' are of the same value, else `false`.
 */
isSame(null, undefined) // false
isSame(null, '') // false
isSame(0, '') // false
isSame(null, null) // true
isSame({a:1, b:2}, {b:2, a:1}) // true
isSame([1,2,3,4,5], [2,1,4,5,3]) // true
isSame([1,2,3,4,5, new Set([1,2,3])], [new Set([3,2,1],2,1,4,5,3]) // true
isSame([{a:1,b:1}, [1,2,3]], [[3,2,1], {b:1,a:1}]) // true

/**
 * @param {*} value.
 * @returns {array} Returns the keys of the value
 */
keys({a: 1, b:2, c:3}) // ['a', 'b', 'c']
keys([1, 2, 3]) // ['0', '1', '2']
keys(new Map([['a', 1], ['b', 2], ['c', 3]])) // ['a', 'b', 'c']

/**
 * @param {*} value.
 * @returns {array} Returns the values of the value
 */
values({a: 1, b:2, c:3}) // [1, 2, 3]
values([1, 2, 3]) // [1, 2, 3]
values(new Map([['a', 1], ['b', 2], ['c', 3]])) // [1, 2, 3]

/**
 * @param {string} value.
 * @param {string} index.
 * @returns {number} Returns the index of the letter in the alphabet
 */
alphabetIndex('a') // 0
alphabetIndex('z') // 25
alphabetIndex('abc', 1) // 1

/**
 * @param {number} value1.
 * @param {number} value2.
 * @returns {number} Returns the sum of two numbers
 */
plus(0.1, 0.2) // 0.3
// 0.1 + 0.2  ==> 0.30000000000000004

/**
 * @param {number} value1.
 * @param {number} value2.
 * @returns {number} Returns the result of subtracting value2 from value1
 */
minus(0.3, 0.2) // 0.1
// 0.3 - 0.2  ==> 0.09999999999999998

/**
 * @param {number} value1.
 * @param {number} value2.
 * @returns {number} Returns the product of two numbers
 */
times(0.1, 0.2) // 0.02
// 0.1 * 0.2 ==> 0.020000000000000004

/**
 * @param {number} value1.
 * @param {number} value2.
 * @returns {number} Returns the result of dividing value1 by value2
 */
div(0.1, 0.2) // 0.5

/**
 * @param {number} value.
 * @param {number} DP.
 * @returns {number} Returns a string representing the value of this number in normal notation to a fixed number of dp decimal places.
 */
toFixed(1.005, 2) // 1.01
// 1.005.toFixed(2) ==> 1.00

/**
 * @param {*} data.
 * @param {*} matchingvalue
 * @returns {boolean} Returns `true` if the matching value exists in the data, else `false`.
 * 'object'、'map' matching key, else matching value
 */
has([1,2,3], 2) // true
has([1,2,3], '2') // false
has([1,2,3,[1]], [1]) // true
has({a: 1, b: 2}, 'a') // true

/**
 * @param {array} data.
 * @param {*} matchingvalue
 * @returns {number} Returns index if the matching value exists in the data, else `-1`.
 * 
 */
indexOf([1,2,3], 2) // 1
indexOf([1,2,3,[1]], [1]) // 3
// [1,2,3,[1]].indexOf([1]) ==> -1

/**
 * @param {array<any>} data.
 * @param {function} comparison default: (a:any, b:any, compare:Function, aType:string, bType:string) => a - b
 * @param {object} orderConfig
 * default: {
 * 'null': 0,
 * 'boolean':1,
 * 'NaN': 2,
 * 'symbol': 3,
 * 'number': 4,
 * 'string': 5,
 * 'date': 6,
 * 'array': 7,
 * 'object': 8,
 * 'set': 9,
 * 'map': 10,
 * }
 * @returns {array} Returns the sorted array and mutates the original array at the same time.
 * 
 */
const arr = [{name: 'ignore'}, 1, 'z', 11, 'b', '5', '1']

// comparison function
sort(arr, (a, b) => b - a)
// arr ===> [{name: 'ignore'}, 'z', 'b', '5', '1', 11, 1]

// Configuration Type Order
sort(arr, (a, b) => b - a, {
    number: 0,
    object: 1,
    string: 2
})
// arr ===> [11, 1, {name: 'ignore'}, 'z', 'b', '5', '1']

// Compare an attribute value
const arr = [
    {name: 'Chris', age: 33},
    {name: 'Allen', age: '20'},
    {name: 'StephenA', age: '26'},
    {name: 'Zoey', age: 29},
    {name: 'StephenB', age: '16'}
]

// If the value is a number or a number-like string, can be directly compared
sort(arr, (a, b) => a.age - b.age)
// arr ===> [
//     {name: 'StephenB', age: '16'},
//     {name: 'Allen', age: '20'},
//     {name: 'StephenA', age: '26'},
//     {name: 'Zoey', age: 29},
//     {name: 'Chris', age: 33},
// ]

// If the value is not a number, need to use the comparison function in the callback to compare.
sort(arr, (a, b, compare) => compare(a.name, b.name, (a, b) => b - a))
// arr ===> [
//     {name: 'Zoey', age: 29},
//     {name: 'StephenB', age: '16'},
//     {name: 'StephenA', age: '26'},
//     {name: 'Chris', age: 33},
//     {name: 'Allen', age: '20'},
// ]

/**
 * @param {*} data.
 * @param {function} callback
 * @param {string | function} order 
 * Optional
 * 'reverse'
 * comparison function like ==> (a, b) => b - a
 */
each([1,2,3,4,5], ((value, index, valueType, data) => {
    return 'continue' // skip the current loop
    return false // break the loop
}))

/**
 * @param {*} data.
 * @param {function} callback
 * @param {*} initData
 */
cosnt res = reduce([1,2,3,4,5], ((prev, curr, currIndex, valueType, data) => {
    return prev + curr
    // return 'continue' // skip the current loop
    // return false // break the loop
}))
// res ==> 15

cosnt res = reduce([1,2,3,4,5], ((prev, curr, currIndex, valueType, data) => {
    return prev + curr
}), 10)
// res ==> 25

Test