JS中的数组

数组

1、数组的概念

先是用一个案例来表示：

案例1：计算5名同学的平均分

var a1,a2,a3,a4,a5;
a1 = Number(prompt("请输入分数："));
a2 = Number(prompt("请输入分数："));
a3 = Number(prompt("请输入分数："));
a4 = Number(prompt("请输入分数："));
a5 = Number(prompt("请输入分数："));
var ave = (a1+a2+a3+a4+a5)/5;
alert(ave);

这个程序很简单，但是这还是5名同学的成绩，但要是100人或者1000人呢，难道要真的复制100遍？这里人数是和代码量成正比的。但这样要怎样解决呢？第一反应当然使用循环，但是尝试一下就会发现，循环使用不了，因为无法控制变量a1，a2的值，也就是无法将循环控制变量和变量a1，a2联系起来。

那么现在我们使用另一种方式来求这5名学生的成绩平均分

案例2：

var a = [];
var sum = 0;
for(var i=0; i<10; i++){
    a[i] = Number(prompt("请输入分数："));
    sum += a[i];
}
var ave = sum/ a.length;
alert(ave);

这里是利用数组来求值，这段代码能够实现跟案例1同样的功能，而且是100人的话，只要把循环条件改为i<100即可，整个程序的结构和代码量和人数多少没有关系。

那么这里为什么能和循环结合起来呢？因为我们把变量的表示方式改变了，即名称+序号的方式(a[0],a[1]······)，那么序号是可以用循环变量去控制的

2、数组的定义与元素访问

要怎么用？定义用三种方式：

（1）var a = []; 定义一个空的数组，一个一个往里面加

（2）var a = new Array(); 定义一个数组对象

（3）var a = [0,0,0]; 定义数组内容的初始值

访问元素：数组名+下标；如a[0]  a[3]

在数组中需要注意的是下标是从0开始的，而不是从1开始。同时在使用的时候需要注意的另一个问题就是越界问题，比如5个元素的数组，那么它的下标范围为[0,4]，而不包括5，要是输出5就越界了。

数组是本质：一组变量的集合，或者说是一组内存单元。只不过对于变量的表示方式使用的是“数组名+下标”的方法。

3、数组的常用属性和方法

3.1 数组的属性

告诉我们数组的长度：数组名.length

案例1：计算学生成绩平均分

var a = [];
var sum = 0;
for(var i=0; i<a.length; i++){
    a[i] = Number(prompt("请输入分数："));
    sum += a[i];
}
var ave = sum/ a.length;
alert(ave);

通过该属性可以改变数组的长度，案例2：

var a = [];
var sum = 0;
a.length = 5;
for(var i=0; i<a.length; i++){
    a[i] = Number(prompt("请输入分数："));
    sum += a[i];
}
var ave = sum/ a.length;
alert(ave);

3.2 数组的常用方法

（1）unshift()：在数组头部添加元素

shift()：删除数组头部的元素，返回值是删除的头部元素

（2）push：在数组的尾部插入元素，返回值为改变后（添加元素后）数组的长度

pop：从数组的尾部删除最后一个元素，返回值是被删除的元素

var a = ["我","思","好","你","我","他"];
/*a[a.length] = "!";
a[a.length] = "?";*/
var b = a.push("说","你好");//在尾部添加元素
var c = a.pop("你好");//删除数组最后的元素
alert(a);
alert(b);
alert(c);

（3）indexOf：查找在数组中重复出现的元素第一次出现的位置，它的返回值是该元素的下标；

lastIndexOf：查找在数组中重复出现的元素的最后一次出现的位置，返回值是该元素的下标。

var a = ["我","思","好","你","我","他"];
//    var b = a.indexOf("我");//查找第一个重复出现的元素
    var c = a.lastIndexOf("我");//查找重复出现的元素最后一次出现的位置
    alert(a);
    alert(c);

（4）slice(开始位置的下标，结束位置的下标)：提取数组中指定的连续的子数组。概括起来就是前包括，后不包括（特点）

var a = ["我","思","好","你","我","他"];
var b = a.slice(2,4);
alert(b);

（5）splice：（开始删除位置的下标，要删除元素的长度，要选择或者替换的内容），splice的含义是剪接，也就是有“加”有“减”，前两个参数元素定义“剪”的部分，第三个参数定义“接”的部分，经过不同参数组合就可以实现以下三个功能：

①删除操作：删除数组中指定的任意元素

②插入操作：在数组中指定的位置插入元素

③替换操作：在数组中替换指定位置的元素（要被替换的被删掉，输入新元素）

/*数组的删除、插入、替换*/
//删除
var a = ["我","思","好","你","我","他"];
var b = a.splice(3,3);//指定要删除的元素的下标和长度
alert(a);//输出的结果为：我，思，好
alert(b);//输出的结果为：你，我，他

//插入
var a = ["我","思","好"];
a.splice(3,0,"无所谓谁是谁非");
alert(a);

/*替换*/
var a = ["我","思","好"];
a.splice(2,2,"说","什么");
alert(a);

（6）reverse：将数组中的元素反序输出。在原数组的基础上进行反序输出，不会再创建一个新的数组

var a = [4,5,6,7,8,9];
 var b = a.reverse();
alert(a);
alert(b);//两个输出结果一样

（7）map：原数组的映射，经过函数的加工，返回一个新数组

一般我们传递是参数都是数值、字符串等类型的数据，有些时候可能需要传递一个函数，那么如何去传递一个函数呢？

案例：

var a = [2,4,6,8];
var b = a.map(fun);
alert(a);

function fun(value, index ,self){ 
    self[index] = value * value;
}

我们还可以将以上内容简写为：

var a = [2,4,6,8];
var b = a.map(function(value, index ,self){//以前function后面总是跟着一个函数名，现在没有是匿名函数
    self[index] = value * value;
});
alert(a);

这其实就是匿名函数。
案例：经过函数的加工，输出一个新的数组

var a = [2,4,6,8];
var b = a.map(function(value, index ,self){
    self[index] = value * value;
});
alert(a);

上面的案例是用了三个参数，还可以使用一个参数的。

var a = [2,4,6,8];
var b = a.map(function(value){
    return value * value;
});
alert(a);
alert(b);

两个程序输出的结果都是一样的。

4、for-in循环

这里用两个案例来说明：

案例1：写一个数组，让数组里面的值相加

var sum = 0;
var array = [1,2,3,4,5,6];
array[10] = 10;
//alert(array);
for(var i=0; i<array.length; i++){
    alert(array[i]);
    sum += array[i];//所有的数相加
}
alert(sum);

上面使用了for循环，下面使用for-in循环

var sum = 0;
var array = [1,2,3,4,5,6];
array[10] = 10;
//alert(array);

for(var j=0 in array){
    //alert(array[j]);
    sum += array[j];
}
alert(sum);

其实这两个输出的结果是一样的，但是虽然结果一样，但是for循环会把所有的值都加上，for-in循环只是有那个数就加上那个数。