Javascript内置对象之Array数组对象：创建数组的两种方式 检测是否为数组 添加删除数组元素 翻转数组/数组排序 查找索引 数组转换字符串 连接数组 截取数组 删除数组

一、创建数组的两种方式

1. 利用数组字面量

        var arr = [1, 2, 3];
        console.log(arr[0]);
        //输出结果：1

2. 利用new Array()

        var arr1 = new Array(); 
        console.log(arr1);
        // 创建了一个空的数组
           
        var arr2 = new Array(2);  
        console.log(arr2);
        // 如果只传入一个参数，则参数规定了数组的长度
        //这个2 表示 数组的长度为 2  里面有2个空的数组元素 

        var arr3 = new Array(2, 3); 
        console.log(arr3);
         //如果传入了多个参数，则参数称为数组的元素
        // 等价于 [2,3]  这样写表示 里面有2个数组元素 是 2和3    

二、检测是否为数组

1. instanceof 运算符 它可以用来检测是否为数组

        var arr = [];
        var obj = {};
        console.log(arr instanceof Array);//输出结果：true
        console.log(obj instanceof Array);//输出结果：false

2. Array.isArray(参数); H5新增的方法 ie9以上版本支持

         var arr = [];
         var obj = {};
         console.log(Array.isArray(arr)); //输出结果：true
         console.log(Array.isArray(obj)); //输出结果： false

三、 添加/删除数组元素

1. 末尾添加（一个或多个数组）
   push（参数1....）

var arr = [1, 2, 3]; 
console.log(arr.push(4, 5)); //输出结果：5
console.log(arr); //输出结果：[1，2，3，4，5]
 //返回的是新数组的长度5

2. 数组的开头添加(一个或多个元素)
   unshift（参数1....）

 var arr = [1, 2,3];
 console.log(arr.unshift('4', '5'));//输出结果：5
  console.log(arr);//输出结果：[4,5,1,2,3]
  //返回的是新数组的长度5

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

 var arr = [1, 2, 0];
 console.log(arr.pop());//输出结果：[1, 2]

4. 删除数组的第一个元素
   shift()

 var arr = [6, 2, 0];
 console.log(arr.shift());//输出结果：[2, 0]

注意：push、unshift为增加元素方法；pop、shift为删除元素的方法

四、reverse()翻转数组/ sort()数组排序

1. 翻转数组
   reverse()

        var arr = [1,2,3];
        arr.reverse();
        console.log(arr);
        //输出结果3,2,1

2. 数组排序（冒泡排序）
   sort()

        var arr1 = [1, 4, 7, 2];
        arr1.sort()
        console.log(arr1);
        //输出结果1，2，4，7;小于10的数不加升序、降序不会出现错误
       
        var arr1 = [13, 4, 77, 1, 7];
         arr1.sort()
        console.log(arr1);
        //不加升序、降序的输出结果为1，13，4，7，77

         //升序
         var arr2 = [13, 4, 77, 1, 7];
        arr2.sort(function(a, b) {
          return a - b; //升序的顺序排列
        });
        console.log(arr2);

        // 降序
        var arr3 = [13, 4, 77, 1, 7];
        arr3.sort(function(a, b) {
            return b - a; // 降序的顺序排列
        });
        console.log(arr3);
         

五、查找数组索引方法indexOf() /lastIndexOf()

方法名	说明	返回值	注意
indexOf(‘要查找的字符’, [起始的位置]1)	在数组中查找给定元素的索引号从前往后查找	如果存在则返回索引号；如果不存在则返回-1	如果给定元素在一组数组中同时多次出现，则返回的是从起始查找的位置开始第一次出现的给定元素的索引号
lastIndexOf()	在数组中查找给定元素的索引号从后往前查找	如果存在则返回索引号；如果不存在则返回-1	如果给定元素在一组数组中同时多次出现，则返回的是最后一次出现的给定元素的索引号

使用：

//1.indexOf()在数组中查找给定元素的索引号    从前往后查找
        var arr = ['red', 'green', 'blue', 'pink'];
        console.log(arr.indexOf('blue'));
        //输出结果：2
         var arr1 = ['red', 'green', 'blue', 'pink', 'blue'];
         console.log(arr1.indexOf('blue'));
         //输出结果：2
          var arr2 = ['red', 'green', 'pink';
          console.log(arr2.indexOf('blue'));
         //输出结果：-1
      var arr1 = ['red', 'green', 'blue', 'pink', 'blue'];
         console.log(arr1.indexOf('blue',3));
         //在索引号为3后的字符开始查找   输出结果：4

         
     //2.  lastIndexOf()  在数组中查找给定元素的索引号  从后往前查找
        var arr3 = ['red', 'green', 'blue', 'pink'];
        console.log(arr3. lastIndexOf('blue'));
        //输出结果：2
        var arr4 = ['red', 'green', 'blue', 'pink', 'blue'];
         console.log(arr4.lastIndexOf('blue'));
         //输出结果：4
          var arr5 = ['red', 'green', 'pink';
          console.log(arr5.lastIndexOf('blue'));
         //输出结果：-1

六、 toString() /join() 数组转换为字符串

1. toString() 将数组转换为字符串，逗号分隔每一项

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

2.join(分隔符)
如果 join()内为空，则默认为 ，

         
        var arr1 = ['green', 'blue', 'pink'];
        console.log(arr1.join()); // green,blue,pink
        console.log(arr1.join('-')); // green-blue-pink
        console.log(arr1.join('&')); // green&blue&pink

七、concat()连接数组

• 连接两个或多个数组
• 不影响原数组
• 返回一个新数组
  使用

var arr1 = [1, 2, 3];
        var arr2 = [4, 5, 6];
        var arr3 = [7, 8, 9];
        var num1 = arr1.concat(arr2);
        var num2 = arr1.concat(arr2, arr3);
        console.log(num1); //(6) [1, 2, 3, 4, 5, 6]
        console.log(num2); //(9) [1, 2, 3, 4, 5, 6, 7, 8, 9]

八、slice()数组截取

• 数组截取slice(begin,end)【会提取原数组中索引从 begin 到 end 的所有元素（包含 begin，但不包含 end）】
• 返回被截取项目的新数组

  const num = ['ant', 'bison', 'camel', 'duck', 'elephant'];
        // 提取终止处的索引（从 0 开始），在该索引处结束提取原数组元素。
        // slice 会提取原数组中索引从 begin 到 end 的所有元素（包含 begin，但不包含 end）。

        console.log(num.slice(2));
        // "camel", "duck", "elephant"

        console.log(num.slice(2, 4));
        // "camel", "duck"

        console.log(num.slice(1, 5));
        //"bison", "camel", "duck", "elephant"

        // 如果该参数为负数， 则它表示在原数组中的倒数第几个元素结束抽取。
        // slice(-2,-1) 表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）。
        console.log(num.slice(-2));
        //"duck", "elephant"
        console.log(num.slice(2, -1));
        // "camel", "duck"
        console.log(num.slice(-3, -1));
        // 'camel', 'duck'

九、splice()数组删除

• splice(第几个开始，要删除的个数，是否添加新数组元素)
• 返回被删除项目的新数组
• 注意：会影响原数组

 const num = ['Jan', 'March', 'April', 'June'];
        num.splice(1, 3);
        //第1个开始，要删除2个，什么都不添加
        console.log(num);
        // 改变为新数组'Jan', 'March'

        const num1 = ['Jan', 'March', 'April', 'June'];
        num1.splice(1, 0, 'Feb');
        //第1个开始，要删除0个，在第一个位置添加'Feb'
        console.log(num1);
        //  改变为新数组"Jan", "Feb", "March", "April", "June"
        //此时num1 = ["Jan", "Feb", "March", "April", "June"];


        num1.splice(4, 1, 'May');
        //第4个开始，要删除1个，在第四个位置添加'May'
        console.log(num1);
        // 改变为新数组"Jan", "Feb", "March", "April", "May"
        //此时num1 = ["Jan", "Feb", "March", "April", "May"];

        num1.splice(2, 1, '123');
        //第2个开始，要删除1个，在第二个位置添加'123'
        console.log(num1);
        // 改变为新数组"Jan", "Feb",'123', "March", "May"

---

1. [ ] 内可有可无 ↩︎