javascript-数组方法收集

检测是否是数组

function judgeArr(arr){
    if(Array.isArray(arr)){
        return true;
    }
}

数组去重set方法

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)
}

数组的every和some

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

//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

//map:对数组进行处理返回一个新数组
function mapArr(arr){
  return arr.map(item => item + 10)//箭头函数的{}如果省略,则会默认返回,不用写return
}

entries()

//返回一个数组的迭代对象，该对象包含数组的键值对 (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"]

copyWithin()

/// 从数组的指定位置拷贝元素到数组的另一个指定位置中
// target	必需。复制到指定目标索引位置。
// start	可选。元素复制的起始位置。
// end	可选。停止复制的索引位置 (默认为 array.length)。如果为负值，表示倒数。
//复制数组的前面两个元素到后面两个元素上：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.copyWithin(2, 0);
fruits 输出结果：
Banana,Orange,Banana,Orange

find()

// 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() 方法返回传入一个测试条件（函数）符合条件的数组第一个元素位置。
// 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

fill() 将一个固定值替换数组的元素，填充数组

//语法：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

from()

// 用于通过拥有 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;

includes

// 用来判断一个数组是否包含一个指定的值，如果是返回 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

indexOf 找出元素item在给定数组arr中的位置

// 方法一
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()

//lastIndexOf() 方法可返回一个指定的元素在数组中最后出现的位置，从该字符串的后面向前查找。
//如果要检索的元素没有出现，则该方法返回 -1。
//该方法将从尾到头地检索数组中指定元素 item。开始检索的位置在数组的 start 处或数组的结尾（没有指定 start 参数时）。如果找到一个 item，则返回 item 从尾向前检索第一个次出现在数组的位置。数组的索引开始位置是从 0 开始的。
//如果在数组中没找到指定元素则返回 -1。
//如果你想查找数组首次出现的位置，请使用 indexOf() 方法。
//查找数组元素 "Apple"出现的位置：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var a = fruits.lastIndexOf("Apple");
//a 输出结果： 2

pop()删除数组的最后一个元素

//移除最后一个数组元素
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.pop();
//fruits 结果输出： Banana,Orange,Apple

shift()把数组的第一个元素从其中删除

//从数组中移除元素:
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.shift()
//fruits结果输出: Orange,Apple,Mango

在数组arr末尾添加元素item，不直接修改数组arr，结果返回新的数组

//方法一：普通的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
}

移除数组arr中的所有值与item相等，直接在给定的arr数组上进行性操作

//方法一：普通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;
}

移除数组arr中的所有值与item相等，不直接修改数组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;
}

计算给定数组arr中所有元素的总和

//方法一：普通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;
}

统计数组中item元素出现的次数

//方法一：普通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;
}