1.push—在陣列的尾部添加一個元素（改變原始陣列）

            var arr=[1,2,3,4,5];
            arr.push(6);
            console.log(arr); //[1,2,3,4,5,6]

2.unshift—在陣列的頭部添加一個元素（改變原始陣列）

            var arr=[1,2,3,4,5];
            arr.unshift(0)
            console.log(arr);//[0,1,2,3,4,5]

3.pop—在陣列的尾部洗掉一個元素（改變原始陣列）

            var arr=[1,2,3,4,5];
            arr.pop()
            console.log(arr);//[1,2,3,4]

4.shift—在陣列的頭部洗掉一個元素（改變原始陣列）

            var arr=[1,2,3,4,5];
            arr.shift()
            console.log(arr);//[2,3,4,5]

5.delete—洗掉索引位置的元素（改變原始陣列）(不改變原始陣列的長度)

            var arr=[1,2,3,4,5];
            delete arr[4];
            console.log(arr);//[1, 2, 3, 4, empty]
            console.log(arr.length);// 5

6.splice(index,num,insertValue)—可以替換，洗掉，插入一個新陣列，index為起始索引，num為要洗掉的個數，insertValue為要替換或者插入的新陣列或者為一個元素,詳情請看代碼！

• 洗掉

           var arr=[1,2,3,4,5];
           arr.splice(1,2);//意思是從索引為1的元素開始洗掉2個元素
           console.log(arr);//[1,4,5]

• 插入

            var arr=[1,2,3,4,5];
            arr.splice(1,0,'tx');
            //意思是從索引為1的地方開始，不洗掉元素，插入一個'tx'
            console.log(arr);//[1, "tx", 2, 3, 4, 5]
            arr.splice(1,0,[0,0,0]);
            // 意思是從索引為1的地方開始，不洗掉元素，插入一個陣列
            console.log(arr);//[1, Array(3), "tx", 2, 3, 4, 5]
            arr.splice(1,0,...[0,0,0]);
            //注意這里要插入的數值前面加上了...就可以直接插入
            console.log(arr);//[1, 0, 0, 0, Array(3), "tx", 2, 3, 4, 5]

• 替換

            var arr=[1,2,3,4,5];
            arr.splice(1,1,'tx');//[1, "tx", 3, 4, 5]
            //從索引為1的地方開始，先洗掉1個元素，再插入'tx'
            console.log(arr);
            arr.splice(1,1,[0,0,0]);
            //從索引為1的地方開始，先洗掉1個元素，再插入陣列
            console.log(arr);//[1, Array(3), 3, 4, 5]
            arr.splice(1,1,...[0,0,0]);
            //替換的數值前面加上了...就可以直接替換
            console.log(arr);//[1, 0, 0, 0, 3, 4, 5]

陣列原型擴展方法（求和，替換（等量，不等量），洗掉，插入）

這里用到了陣列的原型（不清楚原型的內容大家請看一下我之前寫的原型擴展的內容，麻煩了）

• 陣列求和（陣列的內容都要求是數值型）
  （當然如果存在字符型等其他型別可以通過JS的型別轉換來轉換為數值型求和）

Array.prototype.sum=function(){
    var sum=0;
    for(var i=0;i<this.length;i++){
        sum+=this[i];
    }
    return sum;
};//陣列求和
    var arr=[1,2,3,4,5];
    var total=arr.sum();
    console.log(total);//15

• 陣列插入

Array.prototype.insert=function(x,newarr){//陣列插入
    // x為要插入起始位置 newarr為要插入的陣列
    this.splice(x,0,...newarr);
    return this;
};
var arr=[1,2,3,4,5];
arr.insert(1,[0,0,0]);
console.log(arr);//[1, 0, 0, 0, 2, 3, 4, 5]

• 數值替換

Array.prototype.displace=function(x,y,newarr){ 
//陣列替換(不等量替換) 替換的陣列可替換指定的個數
    //x為要替換的起始位置 y表示要替換的個數  newarr表示要在這個位置替換的陣列
    this.splice(x,y,...newarr);
    return this;
};
var arr=[1,2,3,4,5];
arr.displace(1,2,[0,0,0,0]);
console.log(arr);//[1, 0, 0, 0, 0, 4, 5]
//----------------------------------------------------------------------
Array.prototype.displaceEqual=function(x,newarr){ 
//陣列替換(等量替換) 替換的陣列多長就替換掉多少元素
    //x為要替換的起始位置  newarr表示要在這個位置替換的陣列
    this.splice(x,newarr.length,...newarr);
    return this;
};
var arr=[1,2,3,4,5];
arr.displaceEqual(1,[0,0,0]);
console.log(arr);//[1, 0, 0, 0, 5]

• 請大家一定要分清楚上面2個替換方式的不同，不等量替換意思是可以指定要替換掉的元素的長度
• 而等量替換不能指定要替換掉的元素的長度，新來的陣列有多長，就替換多長，

7.keys()—回傳陣列的索引

回傳了陣列的索引！陣列也是特殊的物件 索引相當于屬性名

             var  arr=[1,2,3,4,5];
             console.log(Object.keys(arr));
             //["0", "1", "2", "3", "4"]

             for(var i of arr.keys()){
                 console.log(i);
            }
            //輸出：0 1 2 3 4

8.values()—回傳陣列各個元素

            var  arr=[1,2,3,4,5];
            console.log(Object.values(arr));
            //[1,2,3,4,5]
            for(var i of arr.values()){
                console.log(i);
            }
            //輸出 1 2 3 4 5 

9.join()—將陣列中所有元素都轉化為字串并連接在一起，回傳最后生成的字串，

可以指定一個可選的字串在生成的字串中來分隔陣列的各個元素，如果不指定分隔符，默認使用逗號，

            var arr=[1,2,3,4,5];
            console.log(arr.join("-"))
            //1-2-3-4-5
            console.log(arr.join("A"));
            //1A2A3A4A5

10.reverse()—將陣列中的元素顛倒順序，回傳逆序的陣列，

            var arr=[1,2,3,4,5];
            console.log(arr.reverse());//[5,4,3,2,1]

11.sort()—將陣列中的元素排序并回傳排序后的陣列，(改變原陣列)

當不帶引數呼叫sort()時，陣列元素以字母表順序排序(如有必要將臨時轉化為字串進行比較)，

            var arr=['E','C','A','B','A'];
            console.log(arr.sort());//["A", "A", "B", "C", "E"]
            console.log(arr);//["A", "A", "B", "C", "E"]

升序排列

            var arr=[1,3,4,1,2,3,5];
            var newArr=arr.sort(function(a,b){
                return a-b;
            })
            console.log(newArr);//[1, 1, 2, 3, 3, 4, 5]

降序排列

            var arr=[1,3,4,1,2,3,5];
            var newArr=arr.sort(function(a,b){
                return b-a;
            })
            console.log(newArr);//[5, 4, 3, 3, 2, 1, 1]

12.concat()—創建并回傳一個新陣列，它的元素包括呼叫concat()的原始陣列的元素和concat()的每個引數，

            var arr=[1,2,3,4,5]
            var a1=arr.concat(10,20);
            var a2=arr.concat([10,20]);
            var a3=arr.concat([10,20],[30,40]);
            var a4=arr.concat([10,[20,30]]);
            console.log(a1);//[1, 2, 3, 4, 5, 10, 20]
            console.log(a2);//[1, 2, 3, 4, 5, 10, 20]
            console.log(a3);//[1, 2, 3, 4, 5, 10, 20, 30, 40]
            console.log(a4);//[1, 2, 3, 4, 5, 10, Array(2)]
            console.log([...arr,10,20]);//[1, 2, 3, 4, 5, 10, 20]

13.slice()—回傳指定陣列的一個片段或子陣列，(不改變原陣列)

它的兩個引數分別指定了片段的開始和結束的位置，

            var arr=[1,2,3,4,5];
            console.log(arr.slice(1,2));//[2]

14.forEach()—從頭至尾遍歷陣列，為每個元素呼叫指定的函式，

           var arr=[1,2,3,4,5];
           arr.forEach(function(value,index,arr){
               console.log(index +'----'+value);
               //0----1 1----2  2----3  3----4  4----5
           })

value為每個元素，index為索引，arr為整個陣列

15.map()—方法將呼叫的陣列的每個元素傳遞給指定的函式，并回傳一個陣列，它包含該函式的回傳值，

            var arr=['tx','88','666'];
            var newArr=arr.map(function(value){
                return value.length
            })
            console.log(newArr);//[2, 2, 3]

16.fliter()—會把所有滿足的元素回傳成一個陣列

        var arr=[12,66,4,12,88];
        var newArr=arr.filter(function(value,index,array){
            return value>=20;
        });
        console.log(newArr);//[66, 88]

17.some—如果找到第一個滿足條件的元素，停止回圈不再查找！滿足就true 否則為false

• filter會把所有滿足的元素回傳
• some回傳布林值,找到一個滿足條件的元素就停止回圈，回傳true,找不到就回傳false

        var arr=[10,20,30,40];
        var flag=arr.some(function(value,index,array){
            return value>=50;
        })
        console.log(flag);//false

18.every()—所有元素都滿足條件才回傳true,有一個元素不滿足就會回傳false

        var arr=[10,20,30,40];
        var flag=arr.every(function(value,index,array){
            return value>=20;
        })
        console.log(flag);//false

19.indexOf()—搜索整個陣列中具有給定值的元素，回傳找到的第一個元素的索引或者如果沒有找到就回傳-1，

var arr=[10,20,30,40,10];
console.log(arr.indexOf(10));//0

20. lastIndexOf()—搜索整個陣列中具有給定值的元素，回傳找到的最后一個元素的索引或者如果沒有找到就回傳-1，

var arr=[10,20,30,40,10];
console.log(arr.lastIndexOf(10));//4

接下來是es6新增加的方法

21. copyWith(target, start, end )—會在當前陣列內部將指定位置的元素復制到其他位置（會覆寫原有元素），回傳當前陣列，

• target—必需，復制到指定目標索引位置，
• start—可選，元素復制的起始位置，
• end–可選，停止復制的索引位置 (默認為 array.length)，如果為負值，表示倒數，

  var arr = [1, 2, 3, 4, 5];
  console.log(arr.copyWithin(0, 2, 4));//[3, 4, 3, 4, 5]
  console.log(arr);//[3, 4, 3, 4, 5]

22.from—將類似陣列的物件轉換為真正的陣列

let arr={
            '0':'1',
            '1':'2',
            '2':'3',
            length:3
        };
            let newArr=Array.from(arr,function(value){return value*2});
            console.log(newArr);//[2,4,6]
        }

23.find—查找陣列中第一個滿足條件的值！找不到就是undefined

 var ary=[
            {
                id:1,
                name:'tx'
            },
            {
                id:2,
                name:'tn'
            }
        ];
        var taget=ary.find(function(value){
            return value.id==2
        });
        console.log(taget);//{id: 2, name: "tn"}

24.findIndex()—查找陣列中第一個滿足條件的索引，找不到回傳-1

let ary=[1,5,10,15];
        
        let index=ary.findIndex(item=>item>9);//2
        console.log(index);
        let index1=ary.findIndex(function(item){
            return item>=20
        })
        console.log(index1);//-1

25.includes()—查看某個陣列是否包含某個值，回傳布林值

注意這里不能是NaN==NaN
但是用includes可以判斷陣列里面是否存在NaN

        var taget=[1,2,3].includes(5);
        console.log(taget);//false
        console.log(NaN==NaN);//false
        console.log([1,2,3,NaN].includes(NaN));//true

26.of—將一組資料轉化為陣列，索引為資料的順序

            let arr=Array.of(1,2,3,4,5);
            let arr1=Array.of(1,'2','3','tx','tn')
            console.log(arr);//[1,2,3,4,5]
            console.log(arr1);//[1,'2','3','tx','tn']

27.fill()—全部替換或者部分替換

        var arr=[1,2,3,4,5,undefined,'6','7'];
        console.log(arr.fill(0));//全部替換為0
        //[0, 0, 0, 0, 0, 0, 0, 0]
        var arr1=[1,2,3,4,5,undefined,'6','7'];
        console.log(arr.fill('x',0,2)); //0的位置開始 替換掉2個元素 替為x
        //["x", "x", 0, 0, 0, 0, 0, 0]
        

最后講解Object.defineProperty()改變陣列的length屬性特征
用法可以看我之前寫的博客里面是詳細介紹到Object.defineProperty()用法（麻煩了）

            let arr=[1,2,3];
            arr.length=5;
            console.log(arr);//[1, 2, 3, empty × 2]
            Object.defineProperty(arr,"length",{
                writable:false,
                configurable:false,
            });
            arr.length=3;
            console.log(arr.length);// 5 不會改變
            Object.defineProperty(arr,"length",{
                writable:true
            })//這里會直接報錯 ，不能在修改length的特性

到這里我給大家介紹的內容就結束了，希望大家多支持點贊關注，謝謝大家了，