7、数组Array

一、数组Array

（一）、数组概念

一系列数据的集合，每一项可以保存任何类型的数据，称为数组的元素，每个元素之间用逗号隔开 
    备注：数组格式：[1,2,3]

（二）、数组创建方式

1、字面量声明（var arr=[1,2,3]）；推荐使用

2、使用构造函数创建

var arr = new Array();//创建一个空数组
var arr = new Array(7);//创建一个长度为7的数组（数组项都为undefined）
var arr = new Array('王大锤',18 ,'普通青年','广州');//创建数组并同时写入数据

（三）、数组的操作（增、改、查）

1、利用数组的索引，操作数组某个具体的元素。arr[idx]

2、数组的长度 arr.length

3、数组的遍历 for循环

格式：for(变量初始化;判断条件;变量更新){执行语句}

案例：script type="text/javascript">
               var arr = ["laotian","laoxie","laowang"];
               arr[3] = "lemon";
               arr[0] = "xiaotian";
               for(var i=0;i<arr.length;i++){
               console.log(arr[i]);
                }

（四）、数组的方法

1、增删改 ==> 会改变原数组

（1.1）、push(item) ==> 后面添加

往数组尾部添加一个或多个元素，返回数组新的长度 

（1.2）、unshift(item) ==> 前面添加

备注： 增加方法的返回值：数组的长度

往数组开头添加一个或多个元素，返回数组新的长度 

（1.3）、pop() ==> 删除数组的最后一个元素

（1.4）、shift()删除数组的第一个元素

备注： 删除方法的返回值：被删除的那个元素

（1.5）、splice(idx，delNum，item[,item])

备注： splice方法的返回值：被删除的元素组成的数组

在数组中插入、删除、替换的通用方法
（1）splice的参数：
    * idx  起始索引位置
    * delNum  删除数组数量
    * item 插入的元素（可以是多个）
（2）splice的作用：
    * 删除元素  splice(idx,delNum)
    * 添加元素  splice(idx,0,item)
    * 修改元素  splice(idx,1,item)

2、数组的其他方法

（2.1）、slice(start[,end]) ==> 裁切数组

返回值为裁切数组中的某一部分组成的数组
    （1） 从start开始到end(不包括end所对应的元素)
    （2） end省略，代表裁剪到数组的最后一项
    （3）支持负数（正数是从左往右（0-n）负数是从右往左（-1--n））
案例：
    var arr = ["陈剑龙", "张聪聪", "熊家富", "张丰裕", "梁永昌", "徐明贵","吕运学","王乾坤", "何高峰", "彭琰"];
    var res = arr.slice(-5,-2);
    console.log(arr,res);

（2.2）join(分隔符) ==> 转为字符串

将数组拼接成字符串，返回值为拼接后的字符串
（1） 分隔符默认为逗号，也可以自己定义分隔符
案例：
var arr = ["陈剑龙", "张聪聪", "熊家富", "张丰裕", "梁永昌", "徐明贵","吕运学","王乾坤", "何高峰", "彭琰"];
output.innerHTML = arr.join("+");

（2.3）concat(数组1[,数组2]) ==>组合数组

返回一个新数组，这个新数组是由调用这个方法的数组和参数组成
    案例：
    var arr = [111,22,333];
    var brr = [666,888,233];
    var newArr = arr.concat(["aa","bb","vcc"],brr);
    参数可以是多个

（2.4）reverse() ==> 颠倒顺序

将原数组中的元素颠倒顺序,返回倒序后的数组。
案例： 
    var arr = [111,22,666,888,333];
    var crr = arr.reverse();
    console.log(arr,crr);
    console.log(arr,newArr);

（2.5）sort ==> 数组排序

备注：
1、将数组中的元素排序，返回值为排序后的数组
2、默认以字符串的排列方式（转换成ASCII码进行对比）

sort(function(a,b){return a-b;}) 从小到大
        或
sort(function(a,b){return b-a;}) 从大到小
案例：

   var arr = [111,22,666,888,333];
    var res = arr.sort(function(a,b){
        return b-a;
    });
    console.log(arr,res);

（五）、数组排序（扩展）

1、冒泡排序

1、利用的是每一轮比较，当前索引与后一个索引进行值的比较
2、比较轮数为数组长度-1

案例：var arr = [12,3,44,343,55,1,23];
        for(var i = 1;i<= arr.length-1;i++){
            for(var j = 0;j < arr.length-1;j++){
                if(arr[j] > arr[j+1]){
                      var cur = arr[j];
                      arr[j] = arr[j+1];
                      arr[j+1] = cur;
                   }
                   console.log(666);
              }
           }

2、选择排序法

 1、把当前元素分别跟后面的元素对比
 2、把最小的逐个往前排列

 案例：var arr = [12,3,44,343,55,1,23];
        for(var i=0;i<arr.length-1;i++){
            for(var j = i+1;j<arr.length;j++){
                console.log(666);
                if(arr[i] > arr[j]){
                    var cur = arr[i];
                    arr[i] = arr[j];
                      arr[j] = cur;
                  }
              }
          }
          console.log(arr);

3、快速排序（利用递归实现）

案例：var arr = [10, 8, 20, 5, 6, 30, 11,9];
function fastsort(arr){
        // 当数组的长度小于等于1，就没有中间值，就没法比较，可以直接返回 //
    if(arr.length <= 1){
        return arr;
    }
        // 1.找出中间索引 //
    var centerIdx = parseInt(arr.length/2);
        // 2.splice() 删除数组中的某个值，返回被删除的元素组成的数组 //
    var centerItem = arr.splice(centerIdx,1)[0];
        // 3.定义dayuarr、xiaoyuarr，大于中间数就放在dayuarr里面，小于等于中间数就放在xiaoyuarr里面 //
    var dayuarr = [];
    var xiaoyuarr = [];
    for(var i=0;i<arr.length;i++){
        if(arr[i]>centerItem){
            dayuarr.push(arr[i]);
        }else if(arr[i]<=centerItem){
            xiaoyuarr.push(arr[i]);
           }
           }
            return fastsort(xiaoyuarr).concat([centerItem],fastsort(dayuarr));
    }
    var newArr = fastsort(arr);
     console.log(newArr);

（六）、数组的传递及复制

1、传递 var brr = arr;

（1.1）、此时传递的是arr在堆中的地址给brr。所以一旦brr的值进行修改，arr也会受影响。

2、复制

（1.1）、for循环拷贝arr里面的每个元素

（1.2）、slice(start,end)截取数组，不影响原数组

 案例：
    var arr = [1,2,3];
    var brr = arr.slice(0);
    brr[0] = "aa";
    console.log(arr,brr);

（七）、多维数组：数组套数组[[],[],[],....]

也可以用for循环在原有数组中增加

 例： var arr = []
        for(var i = 0;i < 3; i++){
            arr.push([]);
        }
        console.log(arr);

二、ECMAScript5(ES5)Array新增方法

（一）迭代（遍历）方法

全体备注：

​ fn有三个参数 ==> 1、item 数组中的每一项元素 2、idx 索引 3、arr 当前数组

1、forEach(fn) 等同于for循环

 例： var arr = [10,20,30,40,50,55];
         arr.forEach(function(item,idx,arr){
          console.log(item);
      })

2、map(fn) ==> 返回数组

备注：返回一个数组（数组长度等同于原数组的长度），返回的数组里面元素是什么取决于在fn中返回的值

例： var arr = [10,20,30,40,50,55];
        var res = arr.map(function(item,idx,arr){
         return item*10;
// 也可以返回字符串拼接(return '<li>'+item+'</li>') //
     })
     console.log(res);

3、filter(fn) ==> 返回trun后的数组

备注：返回一个数组，存放执行fn后返回 trun的数组元素。利用这个方法对数组元素进行过滤筛选。

例：
    var arr = [10,20,30,40,50,55];
    var res = arr.filter(function(item,idx,arr){
        return item>20;
     })
     console.log(res);

4、some(fn) ==> 判断数组只要有一个满足

备注：判断数组中是元素是否满足 return的条件，只要有即最终返回true（任何一项返回 true，则返回true ）

例：
    var arr = [10,20,30,40,50,55];
    var res = arr.some(function(item,idx,arr){
        return item >50;
    })
    console.log(res);

5、every(fn) ==> 判断数组每个都满足

备注：判断数组中元素是否每一个都满足 return的条件，有一个不满足， 最终返回false

例：
    var arr = [10,20,30,40,50,55];
    var res = arr.every(function(item,idx,arr){
        return item >5;
    })

（二）归并方法 reduce(fn,initval)

备注：这两个方法都会迭代数组中的所有项，然后生成一个最终返回值。

1、fn的参数（prev,item,idx,array ）

备注：fn是每一项调用的函数，函数接受4个参数分别是

（1）prev 上一次函数的返回值
（2） item 当前值
（3）idx（index) 当前索引
（4）arr 当前数组

2、initval的值

（5）若 reduce的第二个参数 initval有值，则prev第一次的值为initval
（6）若reduce的第二个参数initval没有值，则prev第一次的情况会默认以索引为0为对于的元素为prev的值
             

例：
    var res = arr.reduce(function(prev,item,idx){
        return prev+item;
     },0)
     console.log(res);

（三）静态方法

1、Array.isArray() 判断是否为数组

 例：console.log(Array.isArray([1,2,3])); 返回值是true就为数组。

（四）数组的索引方法

1、indexOf(keyword[,startIdx]) （正序）

 例： 
 var arr = [-1,3,45,768,89,687,454,89,454,89];
 console.log(arr.indexOf(89,5));
 （数字5是从第几个索引开始）

2、lastIndexOf(keyword[,startIdx]) （倒序）

 例： 
 var arr = [-1,3,45,768,89,687,454,89,454,89];
console.log(arr.lastIndexOf(89,5));
（数字5是从倒数第几个索引开始）

3、返回keyword所在数组中的索引值，如果数组不存在keyword，则返回-1；

例：
var arr = [-1,3,45,768,89,687,454,89,454,89];
console.log(arr.indexOf(100));

备注：indexOf多应用于： 判断数组中是否存在某个值

例：
arr.indexOf(keyword) == -1
some()