数组

uniqueArray

简单数组去重

/*** 简单数组去重* @param arr* @returns*/
export const uniqueArray = <T>(arr: T[]) => [...new Set(arr)];const arr1 = [1,1,1,1 2, 3];uniqueArray(arr); // [1,2,3]

uniqueArrayByKey

根据 key 数组去重

/*** 根据key数组去重* @param arr* @param key* @returns*/
export function uniqeArrayByKey(arr: any[], key: string) {const obj: Record<string, any> = {}return arr.reduce((prev, item) => {obj[item[key]] ? '' : (obj[item[key]] = true && prev.push(item))return prev}, [])
}const arr = [{ id: 1, parentid: 0 },{ id: 2, parentid: 1 },{ id: 3, parentid: 1 },{ id: 3, parentid: 1 },
]uniqeArrayByKey(arr, 'id')/*** [{ id: 1, parentid: 0 },{ id: 2, parentid: 1 },{ id: 3, parentid: 1 },
];**/

sortCompare

数组根据 key 排序

/*** 排序* arr: 所需排序的数组* prop：排序的依据字段* order：默认true -> 正序（小 -> 大） / false -> 倒序（大 -> 小）*/
export const sortCompare = (arr: any[], prop: string | number, order = true) => {return arr.sort(compare(prop, order))
}function compare(prop: string | number, order: boolean) {return (obj1: Record<string, any>, obj2: Record<string, any>) => {let val1 = obj1[prop]let val2 = obj2[prop]if (!isNaN(Number(val1)) && !isNaN(Number(val2))) {val1 = Number(val1)val2 = Number(val2)}if (order) {if (val1 < val2) return -1else if (val1 > val2) return 1else return 0} else {if (val1 > val2) return -1else if (val1 < val2) return 1else return 0}}
}const arr = [{ order: 1, name: '1' },{ order: 10, name: '10' },{ order: 3, name: '3' },
]const sortArr = sortCompare(arr, order)/*** [{ order: 1, name: '1' },{ order: 3, name: '3' },{ order: 10, name: '10' },
];**/

multiFieldSort

数组根据多个字段排序

/*** multiFieldSort(data, [{ field: 'age', order: 'desc' }, { field: 'name' }, { field: 'salary', order: 'desc' }])* @param {*} arr* @param {*} sortFields* @returns*/
export function multiFieldSort(arr, sortFields) {return arr.sort((a, b) => {for (let i = 0; i < sortFields.length; i++) {let field = sortFields[i].fieldlet order = sortFields[i].order || 'asc'if (a[field] < b[field]) {return order === 'asc' ? -1 : 1}if (a[field] > b[field]) {return order === 'asc' ? 1 : -1}}return 0})
}

getArrayLabelByValue

根据数组和 value 获取数组中的 label,没有返回 undefined

interface IParams {arr: any[]value: anyvalueKey?: stringlabelKey?: stringdefaultValue?: string | number
}/*** 根据数组获取数组中的值* @param param* @returns*/
export function getArrayLabelByValue({arr,value,valueKey = 'value',labelKey = 'label',defaultValue = undefined,
}: IParams) {if (!Array.isArray(arr)) {throw new Error('Type requires an array')}const obj = arr.find(item => String(item[valueKey]) === String(value))return obj ? obj[labelKey] : defaultValue
}/*** {arr,value,valueKey = 'value',labelKey = 'label',defaultValue = undefined,
}*/const arr = [{label: 'Tom',value: '1',},{label: 'Lily',value: '2',},
]getArrayLabelByValue({ arr, value: '2' }) // Lily

shuffle

洗牌算法随机

/*** 洗牌算法随机* @param arr* @returns*/
export function shuffle(arr: any[]) {let result: any[] = [],random: numberwhile (arr.length > 0) {random = Math.floor(Math.random() * arr.length)result.push(arr[random])arr.splice(random, 1)}return result
}const arr = [1, 2, 3]shuffle(arr) // [2,3,1]

compact

去除数组中的无效/无用值

/*** 去除数组中的无效/无用值* @param arr* @returns*/
export function compact(arr: any[]) {return arr.filter(Boolean)
}compact([0, 1, false, 2, '', 3, 'a', 'e' * 23, NaN, 's', 34])// [ 1, 2, 3, 'a', 's', 34 ]

countOccurrences

检测数值出现次数

/*** 检测数值出现次数* @param arr* @param val* @returns*/
export function countOccurrences(arr: any[], val: any) {return arr.reduce((a, v) => (v === val ? a + 1 : a), 0)
}countOccurrences([1, 1, 2, 1, 2, 3], 1) // 3

flatten

指定深度扁平化数组

/*** 指定深度扁平化数组* @param arr* @param depth* @returns*/
export function flatten(arr: any[], depth = 1): any[] {return arr.reduce((a, v) => a.concat(depth > 1 && Array.isArray(v) ? flatten(v, depth - 1) : v), [])
}flatten([1, [2], 3, 4]) // [1, 2, 3, 4]
flatten([1, [2, [3, [4, 5], 6], 7], 8], 2) // [1, 2, 3, [4, 5], 6, 7, 8]

deepFlatten

递归扁平化数组

/*** 递归扁平化数组* @param arr* @returns*/
export function deepFlatten(arr: any[]): any[] {return [].concat(...arr.map(v => (Array.isArray(v) ? deepFlatten(v) : v)))
}deepFlatten([1, [2], [[3], 4], 5]) // [1,2,3,4,5]

difference

查找两个数组之间的差异

/*** 查找两个数组之间的差异* @param a* @param b* @returns*/
export const difference = (a: any[], b: any[]) => {const s = new Set(b)return a.filter(x => !s.has(x))
}difference([1, 2, 3], [1, 2, 4]) // [3]

indexOfAll

返回数组中某值的所有索引

/*** 返回数组中某值的所有索引* @param arr* @param val* @returns*/
export const indexOfAll = (arr: any[], val: any) => arr.reduce((acc, el, i) => (el === val ? [...acc, i] : acc), [])indexOfAll([1, 2, 3, 1, 2, 3], 1) // [0,3]
indexOfAll([1, 2, 3], 4) // []

intersection

两数组的交集

/*** 两数组的交集* @param a* @param b* @returns*/
export const intersection = (a: any[], b: any[]) => {const s = new Set(b)return a.filter(x => s.has(x))
}intersection([1, 2, 3], [4, 3, 2]) // [2, 3]

intersectionBy

两数组都符合条件的交集

可用于在对两个数组的每个元素执行了函数之后，返回两个数组中存在的元素列表。

/*** 两数组都符合条件的交集* @param a* @param b* @param fn* @returns*/
export const intersectionBy = (a: any[], b: any[], fn: (arg0: any) => unknown) => {const s = new Set(b.map(fn))return a.filter(x => s.has(fn(x)))
}intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor) // [2.1]

intersectionWith

先比较后返回交集

/*** 先比较后返回交集* @param a* @param b* @param comp* @returns*/
export const intersectionWith = (a: any[], b: any[], comp: (arg0: any, arg1: any) => any) =>a.filter(x => b.findIndex(y => comp(x, y)) !== -1)intersectionWith([1, 1.2, 1.5, 3, 0], [1.9, 3, 0, 3.9], (a, b) => Math.round(a) === Math.round(b)) // [1.5, 3, 0]

addDeepProperty

给树结构每一层添加一层 deep 用以区分

export function addDeepProperty(tree, deep = 1) {// 添加属性 deep 到当前层级tree.deep = deep// 递归处理子节点if (tree.children && tree.children.length > 0) {tree.children.forEach(child => {addDeepProperty(child, deep + 1)})}return tree
}