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(变量初始化;判断条件;变量更新){执行语句}

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

（四）、数组的方法

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;}) 从大到小
案例：

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

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

1、冒泡排序

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

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

2、选择排序法

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

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

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

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

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

1、传递 var brr = arr;

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

2、复制

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

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

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

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


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

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

二、ECMAScript5(ES5)Array新增方法

（一）迭代（遍历）方法

全体备注：

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1 例：
2     var arr = [10,20,30,40,50,55];
3     var res = arr.every(function(item,idx,arr){
4         return item >5;
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的值

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

（三）静态方法

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

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

（四）数组的索引方法

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

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

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

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

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

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

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

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