今天我要分享的是10个超棒的 JavaScript 数组常用技巧，可以让你在数据处理上得心应手，让你的开发工作事半功倍。

开始吧！

1.push（）

push() 方法可向数组的末尾添加一个或多个元素，并返回新的长度。

    var a = [🍎,🍏,🍉] 
    // var a = [1,2,3]
    //1.push 
    a.push(🍉) 
    console.log("push方法"); 
    console.log(a); 
    //[🍎, 🍏, 🍉, 🍉]
    // [1,2,3,3]

2.pop（）

pop() 方法用于删除数组的最后一个元素并返回。

    //2.pop，此时a为[🍎, 🍏, 🍉, 🍉]
    // pop，此时a为[1,2,3,3]
    a.pop() 
    console.log("pop方法");
    console.log(a); 
    //[🍎, 🍏, 🍉]
    // [1,2,3]

3.shift（）

shift() 方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。

    //3.shift,此时a为[🍎, 🍏, 🍉] 
    // shift,此时a为[1,2,3]
    a.shift() 
    console.log("shift方法"); 
    console.log(a); 
    //[🍏, 🍉]
    // [2,3]

4.unshift （）

unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。

    //4.unshift,此时a为[🍏, 🍉] 
    // unshift,此时a为[2, 3]
    a.unshift(🍏, 🍉) 
    console.log("unshift方法"); 
    console.log(a); 
    //[🍏, 🍉, 🍏, 🍉]
    // [2,3,2,3]

5.sort（）

sort() 方法用于对数组的元素进行排序。

    //5.sort,此时a为[🍏, 🍉, 🍏, 🍉] 
    // sort,此时a为[2, 3, 2, 3]
    a.sort() 
    console.log("sort方法"); 
    console.log(a); 
    //[🍏, 🍏, 🍉, 🍉]
    // [2,2,3,3]

6.reverse（）

reverse() 方法用于颠倒数组中元素的顺序。

    //6.revere,此时a为[🍏, 🍏, 🍉, 🍉] 
    // revere,此时a为[2, 2, 3, 3]
    a.reverse() 
    console.log("reverse方法"); 
    console.log(a); 
    //[🍉, 🍉, 🍏, 🍏]
    // [3,3,2,2]

7.splice（）

作用：删除、替换、添加

1. splice,此时a为[🍉, 🍉, 🍏, 🍏] 相当于[3，3，2，2] 
2. splice（index,howmany,item1,...,itemX）
3. index 必需，整数，规定添加/删除项目的位置，使用负数可以从数组结尾处规定位置。
4. howmany 必需，要删除的项目数量。如果设置为0，则不会删除项目。
5. item1，...，itemX 可选。向数组添加的新项目。

    //此时a为\[🍉, 🍉, 🍏, 🍏]
    //此时a为\[3，3，2，2]
    //(1).删除
    a.splice(0,1) //删除第一个
    console.log("splice删除");
    console.log(a);

    //此时a [🍉, 🍉, 🍏]
    //此时a [3，3，2]
    // (2).替换 把索引为1的元素🍉（3）替换成🍊（a）
    a.splice(1,1,'🍊') 
    //删除元素时，第二个参数我这里设为1，可理解为在索引为1的地方删除1个元素后用新的元素
    //替换被删除的元素
    console.log("splice替换");
    console.log(a);

    // 此时a [🍉, 🍊, 🍏]
    // 此时a [3, a, 2]
    // (3).添加，在🍉（3）后添加🍇（4） ，即在索引为1的地方增加一个元素🍇（4）
    a.splice(1,0,🍇) 
    // //添加元素时，第二个参数为0，可理解为在索引为1的地方删除0个元素后用新的元素
    //替换删除的元素
    console.log("splice添加");
    console.log(a);
    // 此时a [🍉, 🍇 , 🍊 , 🍏]
    // 此时a [3, 4 , a , 2]

8.split（）

split() 方法用于把一个字符串分割成字符串数组。 stringObject.split(separator,howmany)

1. separator 必需。字符串或正则表达式，从该参数指定的地方分割 stringObject。
2. separator是一个空字符时，会返回一个单字符的数组。
3. howmany 可选。该参数可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。

    var b = "f-ff-gg-ll-kkk";
    // var b = "🍉-🍉🍉-🍊🍊-🍏🍏-🍇🍇🍇";
    var c = b.split("-",3);
    console.log(c);
    //["f", "ff", "gg"]
    // [🍉,🍉🍉,🍊🍊]

9.slice（）

slice() 方法可从已有的数组中返回选定的元素。 arrayObject.slice(start,end)

1. start 必需。规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推。
2. end 可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。

• 2.1 如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。
• 2.2 如果这个参数是负数，那么它规定的是从数组尾部开始算起的元素。

        var d = [1,2,3,4,5,6,7]
        var e;
        e = d.slice(0,1); //从下标0开始，截取1位
        console.log(e);  //[1]
        e = d.slice(-4,-2);  //截取-4到-2(不含-2)之间的元素
        console.log(e);
        //[4, 5]
        e = d.slice(-4,5);  //截取-4到5(不含5)之间的元素
        console.log(e);
        //[4, 5]
        e = d.slice(1,-1);  //截取1到-1(不含-1)之间的元素
        console.log(e);
        //[2, 3, 4, 5, 6]

10.indexOf（）

indexOf()方法，得到数据的索引，找不到就返回-1。从开头（左）向后（右）查询。有两个参数（第一个：查询的参数，第二个：忽略当前位置之前的所有字符）

10.1 String

string的indexOf()是对数据进行了隐式转换，如果参数是数值它会转换为字符来进行查询然后返回索引，String.prototype.indexOf()使用的是==进行比较判断。

    let str = '12341'
    console.log(str.indexOf(1)) // 输出 0
    console.log(str.indexOf('1')) // 输出 0
    console.log(str.indexOf(1, 1)) // 输出 4 ---> 查询1（第一个1），从索引为1（第二个1）开始查询

10.2 Number

Number类型使用，使用indexOf()查找索引会报错。

    let num = 1234

    console.log(num.indexOf(1)) // 报错
    console.log(num.indexOf('1')) // 报错

10.3 Array

Array使用indexOf()方法，是不会对数据进行隐式转换，Array.prototype.indexOf()使用的是===进行比较判断。

    var arr = [1, 2, 3, '4', 1, 2]
    console.log(arr.indexOf(3))  // 输出2
    console.log(arr.indexOf('4')) // 输出3
    console.log(arr.indexOf(4))  // 输出-1
    console.log(arr.indexOf(1, 2)) // 输出 4 ---> 查询1，从索引为2开始查询