[工具（前端）] 数组工具函数

[工具（前端）] 数组处理函数

再继续接上回。这次是一些数组相关处理，包括去重，交集，并集等…

打乱一个数组 洗牌算法

/**
 * 打乱一个数组 洗牌算法
 * @param array 数组
 * @returns {*} 随机打乱后的数组
 */
arrayRandom_Shuffle:(array)=>{
    // 遍历数组，从最后一个元素开始向前遍历
    for (let i = array.length - 1; i > 0; i--) {
        // 生成一个从0到i的随机索引
        const j = Math.floor(Math.random() * (i + 1));
        // 交换当前元素与随机选中的元素
        [array[i], array[j]] = [array[j], array[i]];
    }
    return array;
},

一维数组去重

/**
 * 一维数组去重
 * @param arr
 * @returns {any[]}
 */
uniqueArrayWithSet:(arr)=> {
    return [...new Set(arr)];
},

对象数组去重

/**
 * 对象数组去重
 * @param arr 原数组
 * @param key 唯一的key值
 * @returns {any[]}
 */
uniqueArrayWithObject:(arr, key)=> {
    const map = new Map();
    arr.forEach(item => {
        if(!map.has(item[key])) {
            map.set(item[key], item);
        }
    });
    return Array.from(map.values());
},

数组排序

/**
 * 数组排序
 * @param arr 数组
 * @param key 排序的key
 * @param order 排序顺序 asc 升序 desc 降序
 * @returns {*} 排序后的数组
 */
arraySort:(arr, key, order)=> {
    return arr.sort((a, b) => {
        if (order === 'asc') {
            return a[key] - b[key];
        } else if (order === 'desc') {
            return b[key] - a[key];
        } else {
            throw new Error('Invalid order. Order must be "asc" or "desc".');
        }
    });
},

数组交集

/**
 * 数组交集
 * @param arr1
 * @param arr2
 * @returns {*}
 */
arrayIntersection:(arr1, arr2)=> {
    return arr1.filter(value => arr2.includes(value));
},

对象数组交集

/**
 * 对象数组交集
 * @param arr1
 * @param arr2
 * @param key
 * @returns {*}
 */
arrayIntersectionWithObject:(arr1, arr2, key)=> {
    const map = new Map(arr2.map(item => [item[key], item]));
    return arr1.filter(item => map.has(item[key]));
},

数组并集

/**
 * 数组并集
 * @param arr1
 * @param arr2
 * @returns {*[]}
 */
arrayUnion:(arr1, arr2)=> {
    return [...new Set([...arr1, ...arr2])];
},

对象数组并集

/**
 * 对象数组并集
 * @param arr1
 * @param arr2
 * @param key
 * @returns {*[]}
 */
arrayUnionWithObject:(arr1, arr2, key)=> {
    const map = new Map(arr1.map(item => [item[key], item]));
    return [...arr2.filter(item => !map.has(item[key])), ...arr1];
},

数组差集

/**
 * 数组差集
 * @param arr1
 * @param arr2
 * @returns {*[]}
 */
arrayDifference:(arr1, arr2)=> {
    return arr1.filter(value => !arr2.includes(value));
},

对象数组差集

/**
 * 对象数组差集
 * @param arr1
 * @param arr2
 * @param key
 * @returns {*}
 */
arrayDifferenceWithObject:(arr1, arr2, key)=> {
    const map = new Map(arr2.map(item => [item[key], item]));
    return arr1.filter(item => !map.has(item[key]));
},