用es6 封装的对数组便捷操作的算法

/*
* @Description: 对数组的基本操作
* @LastEditors: Please set LastEditors
* @Date: 2019-04-26 12:00:19
* @LastEditTime: 2019-07-17 09:54:59
*/

var $ = require("jquery");

const arrayBase = {};

/**
* @description: 数组重小到大排序，返回新数组
* @param {type} Arr 数组
* @return:
*/

arrayBase.minToMax = Arr => {
var min;
for (var i = 0; i < Arr.length; i++) {
for (var j = i; j < Arr.length; j++) {
if (Arr[i] > Arr[j]) {
min = Arr[j];
Arr[j] = Arr[i];
Arr[i] = min;
}
}
}
return Arr;
};

/**
* @description: 数组去重复最简单方法
* @param {type} arr 类型： 数组
* @return:
*/

arrayBase.formatDedupeArr = arr => [...new Set(arr)];

/**
* @description: 计算数组中值的出现次数。
* @param {type} arr 数组
* @param {type} value 值
* @return:
*/
arrayBase.countOccurrences = (arr, value) =>
arr.reduce((a, v) => (v === value ? a + 1 : a + 0), 0);
//结果展示 // countOccurrences([1,1,2,1,2,3], 1) -> 3

/**
* @description: 返回两个数组之间的差异
* @param {type} a 数组a
* @param {type} b 数组b
* @return:
*/
arrayBase.difference = (a, b) => {
debugger;
const c = new Set(b);
return a.filter(x => !c.has(x));
};
//结果展示 // difference([1,2,3], [1,2,4]) -> [3]

/**
* 返回两个数组之间 不相同的值 也就是对称差
* @description: 从每个数组创建一个Set, 然后对它们中的每一个都使用Array.filter(), 以便只保留其他值中不包含的数值。
* @param {type}
* @return:
*/

arrayBase.symmetricDifference = (a, b) => {
const sA = new Set(a),
sB = new Set(b);
return [...a.filter(x => !sB.has(x)), ...b.filter(x => !sA.has(x))];
};
//返回结果以及使用方法
// symmetricDifference([1,2,3], [1,2,4]) -> [3,4]

/**
* @description: 返回两个数组中存在的相同的值， 也就是 取两个数组的并值
* @param {type}
* @return:
*/
arrayBase.intersection = (arr1, arr2) => {
const arr3 = new Set(arr2);
return a.filter(x => s.has(x));
};
//结果如下 : intersection([1,2,3], [4,3,2]) -> [2,3]

// /**
// * @description: 移除数组中的元素，直到传递的函数返回 true，返回数组中其余元素
// * @param {type}
// * @return:
// */

/**
* @description: 拼合数组 使用Array.reduce()获取数组中的所有元素和concat()以拼合它们。
* @param {type}
* @return:
*/

arrayBase.flatten = arr => arr.reduce((a, v) => a.concat(v), []);
//结果展示 // flatten([1,[2],3,4]) -> [1,2,3,4]

/**
* 根据给定函数对数组元素进行分组。
* @description: 使用Array.map()将数组的值映射到函数或属性名。使用Array.reduce()创建一个对象, 其中的键是从映射的结果生成的。
* @param {type} arr 数组
* @param {type} func 分组的函数或者条件
* @return:
*/

arrayBase.groupBy = (arr, func) =>
arr
.map(typeof func === "function" ? func : val => val[func])
.reduce((acc, val, i) => {
acc[val] = (acc[val] || []).concat(arr[i]);
return acc;
}, {});

//结果如下 ： // groupBy([6.1, 4.2, 6.3], Math.floor) -> {4: [4.2], 6: [6.1, 6.3]}
// groupBy(['one', 'two', 'three'], 'length') -> {3: ['one', 'two'], 5: ['three']}

/**使用函数将数组的值映射到对象, 其中键值对由原始值作为键和映射值组成。
* @description: 使用匿名内部函数范围来声明未定义的内存空间, 使用闭包来存储返回值。使用新的Array可将该数组与函数的映射放在其数据集上,
* 而逗号运算符返回第二个步骤, 而不需要从一个上下文移动到另一个环境 (由于关闭和操作顺序)。
* @param {type} arr 数组
* @param {type} fu 函数
* @return:
*/

arrayBase.mapObject = (arr, fn) =>
(a => (
(a = [arr, arr.map(fn)]),
a[0].reduce((acc, val, ind) => ((acc[val] = a[1][ind]), acc), {})
))();
//结果如下 ：
// let squareIt = arr => mapObject(arr, a => a*a)
// squareIt([1,2,3]) // { 1: 1, 2: 4, 3: 9 }

/** 对数组进行变异，以筛选出指定的值。
* @description: 使用Array.filter()和Array.includes()来拉出不需要的值。使用Array.length = 0可将传入的数组中的长度重置为零,
* 并将其设置为Array.push(), 以便仅使用所提取的值填充它。
* @param {type} arr 数组
* @param {type} ...args 数组中不需要的值，可以是多个
* @return:
*/
arrayBase.pull = (arr, ...args) => {
let pulled = arr.filter((v, i) => !args.includes(v));
arr.length = 0;
pulled.forEach(v => arr.push(v));
};

//结果如下 ：
// let myArray = ['a', 'b', 'c', 'a', 'b', 'c'];
// pull(myArray, 'a', 'c');
// console.log(myArray) -> [ 'b', 'b' ]

/**
* 从数组中移除给定函数返回false的元素.
* @description: 使用Array.filter()查找返回 truthy 值的数组元素和Array.reduce()以使用Array.splice()删除元素。
* 使用三参数 (func value, index, array调用函数).
* @param {type} 　arr　　　数组
* @param {type} 　func　　函数自定义
* @return:
*/

arrayBase.removeFunction = (arr, func) =>
Array.isArray(arr)
? arr.filter(func).reduce((acc, val) => {
arr.splice(arr.indexOf(val), 1);
return acc.concat(val);
}, [])
: [];
//返回结果使用方法如下：
// remove([1, 2, 3, 4], n => n % 2 == 0) -> [2, 4]

/**
* 返回数组中的随机元素。
* @description: 使用Math.random()生成一个随机数, 将它与length相乘,
* 并使用数学将其舍入到最接近的整数Math.floor()。
* 注意：：：： 此方法也适用于字符串。
* @param {type}
* @return:
*/

arrayBase.shuffle = arr => arr[Math.floor(Math.random() * arr.length)];
//返回结果使用方法如下：
// sample([3, 7, 9, 11]) -> 9

/**随机数组值的顺序。
* @description: 使用Array.sort()可在比较器中使用Math.random()重新排序元素。
* @param {type}
* @return:
*/

arrayBase.shuffle = arr => arr.sort(() => Math.random() - 0.5);
//返回结果使用方法如下：
// shuffle([1,2,3]) -> [2,3,1]

/**
* 返回一个数组, 其中 n 个元素从开始处移除。
* @description: 使用Array.slice()创建数组的切片, 其中包含从开始处取出的n元素。
* @param {type} arr 数组
* @param {type} n开始的 数组索引
* @return:
*/

arrayBase.take = (arr, n = 1) => arr.slice(0, n);
//返回结果使用方法如下：
// take([1, 2, 3], 5) -> [1, 2, 3]
// take([1, 2, 3], 0) -> []

/**
* 返回在两个数组中的任意一个中存在的每个元素。
* @description: 创建一个Set, 其中包含a和b的所有值, 并将其转换为数组。
* @param {type} a 数组
* @param {type} b 数组
* @return:
*/

arrayBase.union = (a, b) => Array.from(new Set([...a, ...b]));
//返回结果使用方法如下：
// union([1,2,3], [4,3,2]) -> [1,2,3,4]

/**
* 创建基于原始数组中的位置分组的元素数组。
* @description: 使用Math.max.apply()获取参数中最长的数组。创建一个以该长度为返回值的数组,
* 并使用 map 函数创建一个分组元素的数组Array.from()如果参数数组的长度不同, 则在未找到任何值的情况下使用undefined。
*
* @param {type}
* @return:
*/

arrayBase.zip = (...arrays) => {
const maxLength = Math.max(...arrays.map(x => x.length));
return Array.from({ length: maxLength }).map((_, i) => {
return Array.from({ length: arrays.length }, (_, k) => arrays[k][i]);
});
};
//返回结果使用方法如下：
//zip(['a', 'b'], [1, 2], [true, false]); -> [['a', 1, true], ['b', 2, false]]
//zip(['a'], [1, 2], [true, false]); -> [['a', 1, true], [undefined, 2, false]]

/**
* 返回数字数组的平均值。
* @description: 使用Array.reduce()将每个值添加到累加器中, 并以0的值初始化, 除以数组的length。
* @param {type} arr 数字数组
* @return:
*/

arrayBase.arrayAverage = arr =>
arr.reduce((acc, val) => acc + val, 0) / arr.length;
// arrayAverage([1,2,3]) -> 2

/**
* 返回一个数字数组的总和。
* @description: 使用Array.reduce()将每个值添加到累加器中, 并以0值初始化.
* @param {type}
* @return:
*/

arrayBase.arraySum = arr => arr.reduce((acc, val) => acc + val, 0);
// arraySum([1,2,3,4]) -> 10

/**
* 将数字转换为数字数组
* @description: 将数字转换为字符串, 在 ES6 ([...string]) 中使用扩展运算符生成数组。使用Array.map()和parseInt()将每个值转换为整数。
* @param {type}
* @return:
*/

arrayBase.digitize = n => [...("" + n)].map(i => parseInt(i));
// digitize(2334) -> [2, 3, 3, 4]

/**
* 返回数字数组的中间值。
* @description: 找到数组的中间, 使用Array.sort()来对值进行排序。如果length为奇数, 则返回中点的数字, 否则为两个中间数的平均值。
* @param {type}
* @return:
*/

arrayBase.median = arr => {
const mid = Math.floor(arr.length / 2),
nums = arr.sort((a, b) => a - b);
return arr.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2;
};
// median([5,6,50,1,-5]) -> 5
// median([0,10,-2,7]) -> 3.5

/**
* 计算两个数字之间最大的公共除数。
* @description: 使用递归。基本情况是当y等于0时。在这种情况下, 返回x。否则, 返回y的 GCD 和除法的其余部分x/y.
* @param {type}
* @return:
*/

arrayBase.gcd = (x, y) => (!y ? x : gcd(y, x % y));
// gcd (8, 36) -> 4

/**
* 返回指定范围内的随机整数。
* @description: 使用Math.random()生成一个随机数并将其映射到所需的范围, 使用Math.floor()使其成为整数。
* @param {type}
* @return:
*/

arrayBase.randomIntegerInRange = (min, max) =>
Math.floor(Math.random() * (max - min + 1)) + min;
// randomIntegerInRange(0, 5) -> 2

/**
* 将数字四舍五入到指定的位数。
* @description: 使用Math.round()和模板文本将数字舍入到指定的位数。省略第二个参数,decimals舍入为整数。
* @param {type}
* @return:
*/

arrayBase.round = (n, decimals = 0) =>
Number(`${Math.round(`${n}e${decimals}`)}e-${decimals}`);
// round(1.005, 2) -> 1.01

/**
* 对数组对象进行检索，并返回新的数组对象
* @description:
* @param arr 过滤的数组
* @param value 检索的值
* @param key 数组中对象检索的key
* @return:
*/
arrayBase.filterArrayObject = (arr, value, key) =>
arr.filter(item => item[key].indexOf(value) > -1);

/**
* 对数组对象进行检索，并返回新的数组对象
* @description:
* @param arr 过滤的数组
* @param value 检索的值
* @param key 数组中对象检索的key
* @return:
*/
arrayBase.byKyeArray = (arr, key) =>
arr
.map(v => {
return v[key];
})
.join();

//结果如下：
// arr= [{a:1,b:0},{a:2,b:3}]
// filterArrayObject(arr,a) 结果 [1,2];

/**
* 判断两个数组是否一样，顺序无所谓，返回ture
* @description:
* @param listA ,listB 数组
* @return:
*/

arrayBase.compareArray = (listA, listB) => {
//切记的是两个数组，不是的话，都是返回false。 加个判断，验证下
if (listA instanceof Array && listB instanceof Array) {
return (
listA.length === listB.length &&
listA.every(a => listB.some(b => a === b)) &&
listB.every(_b => listA.some(_a => _a === _b))
);
} else {
console.log("输入的listA，或者listB字段不是数组类型");
}
};
//const listA = [1, 2, 3]
//const listB = [2, 3, 1]

/**
* 重组数组对象，并重新返回数组
* @description:
* @param property //数组对象的莫一列key
* @return:
*/

// arrayBase.compare (property => (a,b) =>{
// var value1 = a[property];
// var value2 = b[property];
// return value1 - value2;
// })

// console.log(arr.arrayBase.sort(arrayBase.compare('age')))

export default arrayBase;

/**
* @description: 将数组的 位置 替换 ，比如 下标为0 的 换到 最后一项。
* @param {type} array 数组 , start 开始下标, end 结束下标
* @return: 重新返回一个新的数组，数组大小不变。
*/

arrayBase.arrayIndexPsition = (array, start, end) =>
array.splice(start, 1, ...array.splice(end, 1, array[start]));

/**
* @description: 将数组的位置先删除后追加到需要的位置
* @param {type} array, start 删除的位置下标, end 追加的位置下标
* @return:
*/
arrayBase.arrayIndexsplice = (array, start, end) =>
array.splice(start, 1, ...array.splice(end, 0, array[start]));

/**
* @description: 对数组 对象的 某一项的值进行排序
* @param {type} attr 排序的属性 为数组对象中的键 如number属性
* @param {type} rev true表示升序排列，false降序排序
* @return:
*/
arrayBase.sortBy = (attr, rev) => {
if (rev == undefined) {
rev = 1;
} else {
rev = rev ? 1 : -1;
}
return (a, b) => {
a = a[attr];
b = b[attr];
if (a < b) {
return rev * -1;
}
if (a > b) {
return rev * 1;
}
return 0;
};
};

/**
* @description: 从数组中移除 falsey 值。 使用Array.filter()筛选出 falsey 值 (false、null、0、""、undefined和NaN).
* @param {type}
* @return:
*/
arrayBase.compact = arr => arr.filter(Boolean);
//// compact([0, 1, false, 2, '', 3, 'a', 'e'*23, NaN, 's', 34]) -> [ 1, 2, 3, 'a', 's', 34 ]

/**
* @description: 筛选出数组中的非唯一值 对于只包含唯一值的数组, 请使用Array.filter()。
* @param {type}
* @return:
*/
arrayBase.filterNonUnique = arr =>
arr.filter(i => arr.indexOf(i) === arr.lastIndexOf(i));
// filterNonUnique([1,2,2,3,4,4,5]) -> [1,3,5]