function judgeArr(arr){
if(Array.isArray(arr)){
return true;
}
}function changeReArr(arr){
return Array.from(new Set([1,2,2,3,5,4,5]))
}
或者
function changeReArr(arr){
return [...new Set([1,2,2,3,5,4,5])]
}let arr = [1,4,3,6,2,0,7]
arr.sort((a,b)=>{
return a-b //将arr升序排列,如果是倒序return -(a-b)
})
//[0, 1, 2, 3, 4, 6, 7]
let obj = [{id:1},{id:4},{id:8},{id:2}]
obj.sort((a,b)=>{
return a.id - b.id;
})
//[{"id":1},{"id":2},{"id":4},{"id":8}]function max(arr){
return Math.max(...arr)
}
function max1(arr){
return Math.max.apply(null,arr)
}function allTrueArr(arrs){
return arr.every((arr)=>{
return arr>-1;//如果数组的每一项都满足则返回true,如果有一项不满足返回false,终止遍历
})
}
function OneTrueArr(arrs){
return arr.some((arr)=>{
return arr>0;//如果数组有一项满足则返回true,终止遍历,每一项都不满足则返回false
})
}//filter:过滤满足某一条件的数组值,并返回新数组
function filterArr(arr, operator, judgeVal){
return arr.filter(item => {
if (operator == ‘>‘) {
return item > judgeVal;
} else if (operator == ‘<‘) {
return item < judgeVal;
} else if (operator == ‘==‘) {
return item == judgeVal;
}
})
}//map:对数组进行处理返回一个新数组
function mapArr(arr){
return arr.map(item => item + 10)//箭头函数的{}如果省略,则会默认返回,不用写return
}//返回一个数组的迭代对象，该对象包含数组的键值对 (key/value)。迭代对象中数组的索引值作为 key， 数组元素作为 value。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
let x = fruits.entries();
x.next().value //[0, "Banana"]
x.next().value //[1, "Orange"]
x.next().value //[2, "Apple"]
x.next().value //[3, "Mango"]/// 从数组的指定位置拷贝元素到数组的另一个指定位置中
// target 必需。复制到指定目标索引位置。
// start 可选。元素复制的起始位置。
// end 可选。停止复制的索引位置 (默认为 array.length)。如果为负值，表示倒数。
//复制数组的前面两个元素到后面两个元素上：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.copyWithin(2, 0);
fruits 输出结果：
Banana,Orange,Banana,Orange// find() 方法返回通过测试（函数内判断）的数组的第一个元素的值。
// find() 方法为数组中的每个元素都调用一次函数执行：
// 当数组中的元素在测试条件时返回 true 时, find() 返回符合条件的元素，之后的值不会再调用执行函数。
// 如果没有符合条件的元素返回 undefined
// find() 对于空数组，函数是不会执行的。
// find() 并没有改变数组的原始值。
//获取数组中年龄大于 18 的第一个元素
var ages = [3, 10, 18, 20];
function checkAdult(age) {
return age >= 18;
}
function myFunction() {
document.getElementById("demo").innerHTML = ages.find(checkAdult);
}
//fruits 输出结果： 18// findIndex() 方法返回传入一个测试条件（函数）符合条件的数组第一个元素位置。
// findIndex() 方法为数组中的每个元素都调用一次函数执行：
// 当数组中的元素在测试条件时返回 true 时, findIndex() 返回符合条件的元素的索引位置，之后的值不会再调用执行函数。
// 如果没有符合条件的元素返回 -1
// findIndex() 对于空数组，函数是不会执行的。
// findIndex() 并没有改变数组的原始值。
//获取数组中年龄大于等于 18 的第一个元素索引位置
var ages = [3, 10, 18, 20];
function checkAdult(age) {
return age >= 18;
}
function myFunction() {
document.getElementById("demo").innerHTML = ages.findIndex(checkAdult);
}
//fruits 输出结果： 2//语法：array.fill(value, start, end)
var newArray = new Array(10).fill(“1”);
console.log(newArray); // returns [“1”, “1”, “1”, “1”, “1”, “1”, “1”, “1”, “1”, “1”, “1”]
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.fill("Runoob");
// fruits 输出结果：Runoob,Runoob,Runoob,Runoob
//填充 "Runoob" 到数组的最后两个元素：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.fill("Runoob", 2, 4);
//输出结果： Banana,Orange,Runoob,Runoob// 用于通过拥有 length 属性的对象或可迭代的对象来返回一个数组。 如果对象是数组返回 true，否则返回 false。
//下面的实例返回集合中包含的对象数组。
var setObj = new Set(["a", "b", "c"]);
var objArr = Array.from(setObj);
objArr[1] == "b"; // true
//下面的实例演示如何使用箭头语法和映射函数更改元素的值。
var arr = Array.from([1, 2, 3], x => x * 10);
// arr[0] == 10;
// arr[1] == 20;
// arr[2] == 30;// 用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false。
[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false
[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true// 方法一
function indexOf(arr, item) {
if(Array.prototype.indexOf){// 判断浏览器是否支持indexOf方法
return arr.indexOf(item);
}else{
for(var i=0;i<arr.length;i++){
if(arr[i]===item){
return i;
}
}
}
return -1;
}
// 方法二
function indexOf(arr, item) {
if(Array.prototype.indexOf){// 判断浏览器是否支持indexOf方法
return arr.indexOf(item);
} else if (arr.indexOf(item) > 0) {
return arr.indexOf(item)
}else{
return -1
}
}//lastIndexOf() 方法可返回一个指定的元素在数组中最后出现的位置，从该字符串的后面向前查找。
//如果要检索的元素没有出现，则该方法返回 -1。
//该方法将从尾到头地检索数组中指定元素 item。开始检索的位置在数组的 start 处或数组的结尾（没有指定 start 参数时）。如果找到一个 item，则返回 item 从尾向前检索第一个次出现在数组的位置。数组的索引开始位置是从 0 开始的。
//如果在数组中没找到指定元素则返回 -1。
//如果你想查找数组首次出现的位置，请使用 indexOf() 方法。
//查找数组元素 "Apple"出现的位置：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var a = fruits.lastIndexOf("Apple");
//a 输出结果： 2//移除最后一个数组元素
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.pop();
//fruits 结果输出： Banana,Orange,Apple//从数组中移除元素:
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.shift()
//fruits结果输出: Orange,Apple,Mango//方法一：普通的for循环拷贝+push
function append(arr, item) {
let resArr = []
for(let i = 0;i<arr.length;i++){
resArr.push(arr[i])
}
resArr.push(item)
return resArr
}
//方法二：使用concat将传入的数组或非数组值与原数组合并,组成一个新的数组并返回
function append(arr, item) {
return arr.concat(item);
}
//方法三：使用slice浅拷贝+push
function append(arr, item) {
let newArr = arr.slice(0); // slice(start, end)浅拷贝数组
newArr.push(item);
return newArr;
}
//方法四：...扩展运算符
function append(arr, item) {
let resArr = [...arr,item]
return resArr
}//方法一：普通for循环+splice
function removeWithoutCopy(arr, item) {
for(let i=arr.length;i>=0;i--){
if(arr[i]==item){
arr.splice(i,1);
}
}
return arr;
}
//方法二：方法一的另外一种写法
//删除掉一个元素时，要 i–，即删除这个元素后，其他元素位置往前移。
function removeWithoutCopy(arr, item) {
for(let i = 0; i< arr.length; i++) {
if(arr[i]===item) {
arr.splice(i,1);
i--;
}
}
return arr;
}//方法一：filter过滤
function remove(arr, item) {
return arr.filter(res =>{
return res != item;
})
}
//方法二：for循环+push
function remove(arr, item) {
let resArr = []
for(let i = 0;i<arr.length;i++){
if(arr[i]!== item){
resArr.push(arr[i])
}
}
return resArr
}
//方法三：forEach+push
function remove(arr, item) {
let resArr=[];
arr.forEach(v=>{
if(v!==item){
resArr.push(v);
}
})
return resArr;
}
//方法四：for循环+splice
function remove(arr,item){
let resArr= arr.slice(0);
for(let i=0;i<resArr.length;i++){
if(resArr[i] == item){
resArr.splice(i,1);
i--;
}
}
return resArr;
}//方法一：普通for循环
function sum(arr) {
let res = 0
for(let i=0;i<=arr.length;i++){
res +=arr[i]
}
return res
}
//方法二：forEach循环
function sum(arr) {
let res = 0
arr.forEach((value,index,array)=>{
array[index] == value; //结果为true
res+=value;
});
return res;
};
//方法三：reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。
function sum(arr) {
return arr.reduce((pre,cur)=>{
return pre+cur;
})
}
//方法四：eval() 函数可计算某个字符串，并执行其中的 JavaScript 代码。
function sum(arr) {
return eval(arr.join("+"));
}//方法一：slice
function truncate(arr) {
return arr.slice(0,arr.length-1)
}
//方法二：concat/slice+pop
function truncate(arr) {
let resArr = arr.concat()
resArr.pop()
return resArr
}//方法一：concat
function concat(arr1, arr2) {
let resArr = arr1.concat(arr2)
return resArr
}
//方法二：...扩展运算符
function concat(arr1, arr2) {
let resArr = [...arr1,...arr2]
return resArr
}
//方法三：slice+push.apply
function concat(arr1, arr2) {
let resArr = arr1.slice(0);
[].push.apply(resArr,arr2);
return resArr;
}//方法一：先复制前0~index个元素，将item元素插入之后，再拼接index之后的元素
function insert(arr, item, index) {
let resArr = arr.slice(0,index)
resArr.push(item)
resArr = resArr.concat(arr.slice(index))
return resArr
}
//方法二：使用splice方法插入（效率较高）
function insert(arr, item, index) {
let resArr = arr.slice(0);//
resArr.splice(index,0,item);
return resArr;
}
//方法三：push.apply+splice
function insert(arr, item, index) {
let resArr=[];
[].push.apply(resArr, arr);
resArr.splice(index,0,item);
return resArr;
}//方法一：普通for循环
function count(arr, item) {
let reSCount = 0
for(let i = 0;i<=arr.length;i++){
if(arr[i] === item){
reSCount++
}
}
return reSCount
}
//方法二：forEach
function count(arr, item) {
let resCount=0;
arr.forEach(v => {
if(v==item){
resCount++;
}
});
return resCount;
}
//方法三：filter
function count(arr, item) {
let res = arr.filter(v => {
return v === item
});
return res.length;
}
//方法四：map
function count(arr, item) {
let resCount = 0
arr.map(v => {
if(v === item){
resCount++
}
});
return resCount;
}
//方法五：reduce
function count(arr, item) {
let res = arr.reduce( (init,curr)=> {
//如果当前置等于item，该函数值加一
return curr === item ? init+1:init;
},0)
return res;
}//方法一：for/for in/+sort先进行排序，然后判断排序之后的前一个数据是否等于后一个数据，如果是且结果数组没有这个元素
function duplicates(arr) {
let resArr = [];
arr.sort();
for(let i=0;i<arr.length;i++){
if(arr[i]==arr[i-1] && resArr.indexOf(arr[i])==-1){
resArr.push(arr[i]);
}
}
return resArr;
}
//for in
function duplicates(arr) {
let resArr = [];
arr.sort();
for(i in arr){
if(arr[i]==arr[i-1] && resArr.indexOf(arr[i])==-1){
resArr.push(arr[i]);
}
}
return resArr;
}
//方法二：forEach利用索引判断是否重复（使用了两次）
// 运行时间：1184ms 占用内存：77772k
function duplicates(arr) {
var resArr=[];
arr.forEach(v => {
//判断原数组是否有重复数据
//判断结果数组是否已经具有该数据
if(arr.indexOf(v) !=arr.lastIndexOf(v) && resArr.indexOf(v) == -1){
resArr.push(v);
}
});
return resArr;
}
//方法三：reduce先判断数组中元素出现的次数，如果大于1并且结果数组之前无此元素，则将这个元素放到结果数组中
function duplicates(arr) {
let b = [];
let resArr = [];
for (let i= 0; i<arr.length; i++){
b[i] = arr.reduce( (init,curr)=> {
//如果当前置等于item，该函数值加一
return curr === arr[i] ? init+1:init;
},0)
if (b[i] > 1 && resArr.indexOf(arr[i]) === -1){
resArr.push(arr[i]);
}
}
return resArr;
}var numOne = [0, 2, 4, 6, 8, 8];
var numTwo = [1, 2, 3, 4, 5, 6];
var duplicatedValues = […new Set(numOne)].filter(item => numTwo.includes(item));
console.log(duplicatedValues); // returns [2, 4, 6]var mixedArr = [0, “blue”, “”, NaN, 9, true, undefined, “white”, false];
var trueArr = mixedArr.filter(Boolean);
console.log(trueArr); // returns [“blue”, 9, true, “white”]const listChunk = (list,size=1,cacheList=[])=>{
const tmp = [...list]
if(size <= 0) return cacheList
while (tmp.length){
cacheList.push(tmp.splice(0,size))
}
return cacheList;
}原文：https://blog.51cto.com/yzhipeng/2537792