js-utils-chs/src/array/fun.js

自定义工具函数库

// 数据原生方法

/**
 * 数组截取
 * @param {*} arr 
 * @param {*} start 开始截取索引
 * @param {*} end 结束索引
 * @returns 
 */
export function substring(arr, start, end) {
    if (!Array.isArray(arr)) return [];
    if (typeof start !== 'number') start = Number(start);
    if (typeof end !== 'number') end = Number(end);
    if (isNaN(start)) start = 0;
    if (isNaN(end)) end = arr.length;
    return arr.substring(start, end)
}

/**
 * 数组截取
 * @param {*} arr 
 * @param {*} start 开始截取索引
 * @param {*} end 结束索引
 * @returns 
 */
export function substr(arr, start, end) {
    if (!Array.isArray(arr)) return [];
    if (typeof start !== 'number') start = Number(start);
    if (typeof end !== 'number') end = Number(end);
    if (isNaN(start)) start = 0;
    if (isNaN(end)) end = arr.length;
    return arr.substr(start, end)
}

/**
 * 数组添加元素
 * @param {Array} arr  数组
 * @param  {...any} element 要添加的元素 
 * @returns 
 */
export function push(arr, ...element) {
    if (!Array.isArray(arr)) return arr;
    return arr.push(...element);
}

/**
 * 从后面删除元素，只能是一个，返回值是删除的元素
 * @param {Array} arr 
 * @returns 
 */
export function pop(arr) {
    if (!Array.isArray(arr)) return arr;
    return arr.pop();
}

/**
 * 从前面删除元素，只能是一个，返回值是删除的元素
 * @param {Array} arr 
 * @returns 
 */
export function shift(arr) {
    if (!Array.isArray(arr)) return arr;
    return arr.shift();
}

/**
 * 从前面添加元素，添加一个或多个，返回值是添加完后的数组的长度
 * @param {Array} arr 
 * @param  {...any} element 
 * @returns 
 */
export function unshift(arr, ...element) {
    if (!Array.isArray(arr)) return arr;
    return arr.unshift(...element)
}

/**
 * 删除从 index（索引值）开始之后的那 num（默认到数组的结束位置）个元素，返回值是删除的元素数组
 * @param {Array} arr 
 * @param {Number} index 
 * @param {Number} num 
 * @param  {...any} element 
 * @returns 
 */
export function splice(arr, index, num, ...element) {
    if (!Array.isArray(arr)) return arr;
    if (typeof index !== 'number') index = Number(index);
    if (typeof num !== 'number') num = Number(num);
    if (isNaN(index) || isNaN(num)) return arr;

    // 添加元素
    if (element.length > 0) {
        return arr.splice(index, num, [...element])
    }

    // 删除元素
    return arr.splice(index, num)
}

/**
 * 将字符串转化为数组
 * @param {Array} arr 
 * @param {String} str 
 * @returns 
 */
export function split(arr, str = '') {
    return arr.split(str)
}

/**
 * 连接两个数组，返回值是连接后的新数组
 * @param {Array} arr1 
 * @param {Array} arr2 
 * @returns 
 */
export function concat(arr1, arr2) {
    if (!Array.isArray(arr1) || !Array.isArray(arr2)) return arr1;
    return arr1.concat(arr2);
}

/**
 * 将数组进行排序，返回值是排好的数组，默认是按照最左边的数字进行排序（非数字整体大小）
 * @param {Array} arr 
 * @param {Function} fn 
 * @returns 
 */
export function sort(arr, fn) {
    if (!Array.isArray(arr)) return arr
    if (typeof fn !== 'function') {
        return arr.sort();
    }
    return arr.sort(fn);
}

/**
 * 将原数组反转，返回值是反转后的数组
 * @param {Array} arr 
 * @returns 
 */
export function reverse(arr) {
    if (!Array.isArray(arr)) return arr
    return arr.reverse();
}

/**
 * 切去索引值start到索引值end（不包含end的值）的数组，返回值是切出去的数组
 * @param {Array} arr 
 * @param {Number} start 
 * @param {Number} end 
 * @returns 
 */
export function slice(arr, start, end) {
    if (!Array.isArray(arr)) return arr;
    if (typeof start !== 'number') start = Number(start);
    if (typeof end !== 'number') end = Number(end);
    if (isNaN(start)) start = 0;
    if (isNaN(end)) end = arr.length;

    return arr.slice(start, end);
}

/**
 * 遍历数组，无返回值
 * @param {Array} arr 
 * @param {Function} fn 
 */
export function forEach(arr, fn) {
    if (!Array.isArray(arr)) return arr;
    arr.forEach((item, index) => {
        typeof fn === 'function' && fn(item, index)
    })
}

/**
 * 遍历数组(对原数组的值进行操作)，返回一个新数组
 * @param {Array} arr 
 * @param {Function} fn 
 * @returns 
 */
export function mapArray(arr, fn) {
    if (!Array.isArray(arr)) return arr;
    return arr.map((value, index, array) => {
        return typeof fn === "function" ? fn(value, index, array) : index >= 0
    })
}

/**
 * 过滤数组，返回一个满足要求的数组
 * @param {Array} arr 
 * @param {Function} fn 
 * @returns 
 */
export function filter(arr, fn) {
    if (!Array.isArray(arr)) return arr;
    return arr.filter((value, index) => {
        return typeof fn === "function" ? fn(value, index) : index >= 0
    })
}

/**
 * 根据判断条件，遍历数组中的元素，是否都满足，若都满足则返回true，反之返回false
 * @param {Array} arr 
 * @param {Function} fn 
 * @returns 
 */
export function every(arr, fn) {
    if (!Array.isArray(arr)) return arr;
    return arr.every((value, index) => {
        return typeof fn === "function" ? fn(value, index) : index >= 0
    })
}

/**
 * 根据判断条件，遍历数组中的元素，是否存在至少有一个满足，若存在则返回true，反之返回false
 * @param {Array} arr 
 * @param {Function} fn 
 * @returns 
 */
export function some(arr, fn) {
    if (!Array.isArray(arr)) return arr;
    return arr.some((value, index) => {
        return typeof fn === "function" ? fn(value, index) : index >= 0
    })
}

/**
 * 从前往后查找某个元素的索引值，若有重复的，则返回第一个查到的索引值，若不存在，返回 -1
 * @param {Array} arr 
 * @param {any} value 
 * @returns 
 */
export function indexOf(arr, value) {
    if (!value) return -1;
    return arr.indexOf(value);
}

/**
 * 从后往前查找某个元素的索引值，若有重复的，则返回第一个查到的索引值，若不存在，返回 -1
 * @param {Array} arr 
 * @param {any} value 
 * @returns 
 */
export function lastIndexOf(arr, value) {
    if (!value) return -1;
    return arr.lastIndexOf(value)
}

/**
 * 将伪数组变成数组，只要有length的就可以转成数组
 * @param {Object} arr 
 * @returns 
 */
export function from(arr) {
    if (!arr.hasOwnProperty('length')) return arr
    return Array.from(arr);
}

/**
 * 将一组值转换成数组，类似于声明数组
 * @param {any} value 
 * @returns 
 */
export function of(value) {
    if (!value) return [];
    return Array.of(value);
}

/**
 * 找到第一个符合条件的数组成员
 * @param {Array} arr 
 * @param {Function} fn 
 * @returns 
 */
export function find(arr, fn) {
    if (!Array.isArray(arr)) return arr;
    return arr.find((value, index, array) => {
        return typeof fn === "function" ? fn(value, index, array) : index >= 0
    })
}

/**
 * 找到第一个符合条件的数组成员的索引值
 * @param {Array} arr 
 * @param {Function} fn 
 * @returns 
 */
export function findIndex(arr, fn) {
    if (!Array.isArray(arr)) return arr;
    return arr.findIndex((value, index, array) => {
        return typeof fn === "function" ? fn(value, index, array) : index >= 0
    })
}

/**
 * 判断数组中是否包含特定的值
 * @param {Array} arr 
 * @param {Any} value 
 * @returns 
 */
export function includes(arr, value) {
    if (!Array.isArray(arr) || !value) return false;
    return arr.includes(value)
}

/**
 * 使用给定的值，填充一个数组（改变原数组）
 * @param {*} arr 
 * @param {*} target 待填充的元素
 * @param {*} start 开始填充的位置 - 索引
 * @param {*} end 终止填充的位置 - 索引（不包括该位置)
 * @returns 
 */
export function fill(arr, target, start, end) {
    if (!Array.isArray(arr) || !target) return arr
    if (typeof start !== 'number') start = Number(start)
    if (typeof end !== 'number') end = Number(end)
    if (isNaN(start)) start = 0
    if (isNaN(end)) end = arr.length

    return arr.fill(target, start, end)
}

/**
 * 遍历数组的键名
 * @param {Array} arr 
 * @returns 
 */
export function Keys(arr) {
    if (!Array.isArray(arr)) return []
    return arr.Keys();
}

/**
 * 遍历数组键值
 * @param {Array} arr 
 * @returns 
 */
export function values(arr) {
    if (!Array.isArray(arr)) return []
    return arr.values()
}

/**
 * 遍历数组的键名和键值
 * @param {Array} arr 
 * @returns 
 */
export function entries(arr) {
    if (!Array.isArray(arr)) return []
    return arr.entries()
}

/**
 * 在当前数组内部，将制定位置的数组复制到其他位置，会覆盖原数组项，返回当前数组
 * @param {Array} arr 
 * @param {Number} target 必选 索引从该位置开始替换数组项
 * @param {Number} start 可选 索引从该位置开始读取数组项，默认为0.如果为负值，则从右往左读。
 * @param {Number} end 可选 索引到该位置停止读取的数组项，默认是Array.length,如果是负值，表示倒数
 * @returns 
 */
export function copyWithin(arr, target, start, end) {
    if (!Array.isArray(arr) || typeof target !== 'number') return []
    if (typeof start !== 'number') start = Number(start)
    if (typeof end !== 'number') end = Number(end)
    if (isNaN(start)) start = 0
    if (isNaN(end)) end = arr.length

    return arr.copyWithin(target, start, end)
}

/**
 * 判断一个值是否为数组的方法，若为数组，返回true，反之返回false
 * @param {Array} arr 
 * @returns 
 */
export function isArray(arr) {
    return Array.isArray(arr)
}

/**
 * 把数组中的所有元素放入一个字符串，separate表示分隔符，可省略，默认是逗号
 * @param {Array} arr 
 * @param {String} str 
 * @returns 
 */
export function join(arr, str) {
    if (!Array.isArray(arr)) return '';
    if (str === null || str == undefined) return arr.join();
    return arr.join(str)
}

/**
 * 对数组内嵌套的数组“拉平”，就是把数组中的数组的元素挨个拿出来，放数组元素所在位置，返回一个新的数组，不会影响到原来的数组
 * @param {Array} arr 
 * @param {Number} pliy pliy表示拉平的层数，默认是1层，想无限拉平可以传入Infinity关键字
 * @returns 
 */
export function flat(arr, pliy = 1) {
    if (!Array.isArray(arr)) return [];
    return arr.flat(pliy);
}

/**
 * 对原数组的每个成员执行一个函数，相当于执行Array.prototype.map(),然后对返回值组成的数组执行flat()方法。该方法返回一个新数组，不改变原数组。只能展开一层数组
 * arr.flatMap((x) => [x, x * 2])   // [2, 4, 3, 6, 4, 8]
 * @param {Array} arr 
 * @param {Function} fn 
 * @returns 
 */
export function flatMap(arr, fn) {
    if (!Array.isArray(arr)) return [];
    return arr.flatMap((x) => {
        return typeof fn === 'function' ? fn(x) : [x, x * 2]
    })
}

/**
 * 将数组转换为字符串并返回。数组中的元素之间用逗号分隔。
 * @param {Array} arr 
 * @returns 
 */
export function toString(arr) {
    if (!Array.isArray(arr)) return '';
    return arr.toString()
}

/**
 * 对数组中的每个元素执行一个提供的函数（升序执行），将其结果汇总为单个返回值。
 * 接收4个参数：
 * Accumulator (acc) (累计器)
 * Current Value (cur) (当前值)
 * Current Index (idx) (当前索引)
 * Source Array (src) (源数组)
 * @param {Array} arr 
 * @param {Function} fn 
 * @returns 
 */
export function reduce(arr, fn) {
    if (!Array.isArray(arr)) return '';
    return arr.reduce((acc, value, index, array) => {
        return typeof fn === 'function' ? fn(acc, value, index, array) : acc + value
    })
}