JavaScript之 数组的方法

1、contcat

作用：concat() 连接两个或更多的数组，并返回结果。

主要作用有三个：

（1）连接两个或者多个数组

var arr1=[1,2,3,4,5];
    var arr2=[6,7,8,9,0];
    var arr=arr1.concat(arr2);
    console.log(arr);

打印结果：

（2）用来复制数组，产生一个新的数组，且两个数组之间没有引用关系

//直接将arr1赋给arr3，当arr3的值改变时，arr1也改变
    var arr3=arr1;
    arr3[0]=10;
    console.log(arr3,arr1);
   //用concat()产生的arr4的值改变，arr1不变
    var arr4=arr1.concat();
    arr4[0]=10;
    console.log(arr4,arr1);

（3）contcat可以在数组的尾部添加新元素

var arr1=[1,2,3,4,5];
    var arr1=arr1.concat(6,7);
    console.log(arr1);

返回结果为 [1, 2, 3, 4, 5, 6, 7]

2、join：

作用：join() 把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。原数组不发生改变。

    var arr1=[1,2,3,4,5];
//    如果括号中的值为空，默认用“，”连接，返回值为字符串
    var str=arr1.join();
//    如果括号中的值为指定字符串，返回值以指定字符串连接，形成新的字符串
    var str0=arr1.join("%");
    console.log(str,str0);

打印显示：1,2,3,4,5                 1%2%3%4%5

3、push：

作用：push() 向数组的末尾添加一个或更多元素，并返回新的长度。不会产生新数组，原数组改变

 var arr1=[1,2,3,4,5];
//      添加元素，返回值为长度
      var len=arr1.push(1,2,3,4);
//      添加数组，数组算作一个长度
      arr1.push([1,2,3,4]);
      console.log(arr1,len);

返回值：(10) [1, 2, 3, 4, 5, 1, 2, 3, 4, Array(4)] 9

三个案例：

//      给数组之间添加0-100的偶数
       var arr1=[];
       for(i=0;i<100;i+=2){
           arr1.push(i);
       }
       console.log(arr1);
//将arr1中的数保留只能被3整除的数,添加到新的数组中
       var arr2=[];
       for (j=0;j<arr1.length;j++){
               if(arr1[j]%3===0){
               arr2.push(arr1[j]);
               }
       }
       console.log(arr2);
//将arr2中的数保留只能被5整除的数,不产生新的数组
       var arr3=[];
       for(k=0;k<arr2.length;k++){
           if(arr2[k]%5===0){
               arr3.push(arr2[k]);
           }
       }
       arr2=arr3.concat();
       arr3.length=0;
       console.log(arr2);

4、pop：

作用：pop() 删除并返回数组的最后一个元素，不会产生新数组，原来的数组会改变。原数组的长度也会变小。

注意：一般应用的案例，为最后一名删掉。

    var arr=[1,2,3];
//    arr0为其返回值，
    var arr0=arr.pop();
//    返回结果为(2) [1, 2] 3
    console.log(arr,arr0);

典型案例：

//    pop应用中，清空数组的错误做法
//分析：由于pop应用时，length不断改变，所以不会被删除干净
    for(var i=0;i<arr.length;i++){
        arr.pop();
    }
//    返回的结果为var arr=[1,2,3];
    console.log(arr);
//解决1：从后往前删
    for(i=arr.length-1;i>-1;i--){
        arr.pop();
    }
    console.log(arr);
//    解决2：
    var len=arr.length;
    for(var i=0;i<len;i++){
        arr.pop();
    }
    console.log(arr);

以上案例或者，直接

arr.length=0；//清空数组，最简单的做法！！！

5、unshift和shift

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

shift() 删除并返回数组的第一个元素

注意：两者不推荐使用，机制如下：

6、splice：

作用：splice() 删除元素，并向数组添加新元素。

   var arr=[1,2,3,4,5,6,7,8,9,10];
//    添加元素：splice(开始位置，0，添加内容），从开始位置插入添加新的数据
      arr.splice(2,0,8);
      console.log(arr);
//      删除元素：splice(开始位置，要删除的数量），从开始位置删除需要删除的数量数据
       arr.splice(2,2);
       console.log(arr);
//      替换元素：splice（开始位置，要删除的数量，添加的内容），
//       从开始位置删除需要删除的数量内容，并在这个位置再添加新的内容，称为替换
       arr.splice(2,2,10,20);
       console.log(arr);

返回结果：

 (11) [1, 2, 8, 3, 4, 5, 6, 7, 8, 9, 10]0: 11: 22: 103: 204: 65: 76: 87: 98: 10length: 9__proto__: Array(0)
 (9) [1, 2, 4, 5, 6, 7, 8, 9, 10]

(9) [1, 2, 10, 20, 6, 7, 8, 9, 10]

7、indexOf：主要作用是去重

var arr=[1,2,3,4,3,5,6,7,8,9,10];
//查找3这个值，返回的是它的索引位置
var index0=arr.indexOf(3);
console.log(index0);
var arr=[1,2,3,4,3,5,6,7,8,9,10];
//从第三位开始查找3这个值，返回的是它的索引位置
//注意：只能查找重复的元素，不重复的不能从第几个开始查找，否则返回值为-1
var index=arr.indexOf(3,3);
console.log(index);

注意：lastindexOf(3)为从后往前查找

重点：去重

var arr=[1,2,3,3,4,3,6,5,6,7,8,0,9,1,10];
var arr1=[];
for(var i=0;i<arr.length;i++){
    if(arr1.indexOf(arr[i])===-1){
        arr1.push(arr[i]);
    }
}

案例：

//需求：将两个数组中不重复的值取出，不产生新的数组
var arr3=[1,2,3,4,5,6,7,8,9,11,12,15,11];
var arr4=[1,3,5,7,9,12,15,20,16,3];
var arr5=[];
for(var i=0;i<arr3.length;i++){
    if(arr4.indexOf(arr3[i])===-1){
        arr5.push(arr3[i]);
    }
}
arr3=arr5.concat();
arr5.length=0;
console.log(arr3);

8、reverse：

作用：reverse() 颠倒数组中元素的顺序，倒序不排序，只是首尾颠倒，原数组改变，不产生新数组。

9、sort：

作用：sort() 对数组的元素进行排序，没有产生新数组，原数组改变，默认从小到大排序。如果是非数值按照第一位的Ascii码排序。数值也会按照第一位的Ascii码排序。

  var arr=[1,2,3];
    arr.sort(function (a,b) {
//        b-a从小到大，a-b从小到大
        return b-a;
    })
    console.log(arr);

注意：sort(function(a,b){
        *       return a-b  从小到大
        *       return b-a 从大到小
        *       如果a和b是对象，比较对象某个属性大小时，

        *       return a.属性-b.属性

案例：

//    随机抽取0-10之间三个值不重复
    var arr=[];
    for(i=0;i<11;i++) {
        arr.push(i);
    }
        arr.sort(function () {
            return Math.random()-0.5;
        });
    arr.length=3;
    console.log(arr);

10.slice：

作用：slice() 从某个已有的数组返回选定的元素，截取。不改变原数组，生成新数组。

    var arr=[1,2,3,4,5,6,7,8,9,0];
//    截取arr.slice(开始下标,结束下标)
    var arr1=arr.slice(2,3);
    console.log(arr1);
//    复制一个新数组，与原数组无引用关系
     var arr2=arr.slice();

注：开始下标和结束下标都可以为负值，开始值必须小于结束值。为负值从后往前。

如果只有开始下标没有结束下标，则从开始到结束。

//forEach用法
var arr=[1,2,3,4,5,6,7,8,9,0];
var arr1=[];
arr.forEach(function(item,index,array) {
    array[index]++;
});
console.log(arr);

案例：

//arr1中所有能被2整除的数全部加1
var arr1=[1,2,3,4,5,6,7,8,9,0];
var arr=[];
    arr1.forEach(function(item,index,array) {
        if(item%2===0){
            array[index]++;
        }
    });

console.log(arr1);

11、二维数组

//    定义一个二维数组
    var arr=[];
    for(var i=0;i<10;i++){
        arr[i]=[];
        for (var j=0;j<10;j++){
            arr[i][j]=i*10+j;
        }
    }
    console.log(arr);