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