[工具(前端)] 数组处理函数
再继续接上回。这次是一些数组相关处理,包括去重,交集,并集等…
打乱一个数组 洗牌算法
/**
* 打乱一个数组 洗牌算法
* @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]));
},