javascript中的数组



数组的概念

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

vara1,a2,a3,a4,a5,a6,a7,a8,a9,a10;
a1= Number(prompt("请输入分数"));
a2= Number(prompt("请输入分数"));
a3= Number(prompt("请输入分数"));
a4= Number(prompt("请输入分数"));
a5= Number(prompt("请输入分数"));
a6= Number(prompt("请输入分数"));
a7= Number(prompt("请输入分数"));
a8= Number(prompt("请输入分数"));
a9= Number(prompt("请输入分数"));
a10= Number(prompt("请输入分数"));
varave=(a1+a2+a3+a4+a5+a6+a7+a8+a9+a10) / 10;
alert(ave);

这个程序很简单，但是如果是100人呢，怎么解决？

尝试后发现，循环使用不上，因为无法控制变量a1,a2，也就是无法将循环控制变量和a1,a2联系起来。

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

这段代码能够实现同样的功能，而且如果是100人的话，只要把循环改为i<100即可，整个程序的结构和代码量和人数多少没有关系。

为什么和人数没有关系？因为和循环结合起来了

为什么能和循环结合起来？因为我们把变量的表示方式改变了，即名称+序号的方式（a[0]、a[1]……），那么序号是可以用循环变量去控制。

数组的定义与元素访问

定义有三种方式

1. var a = [];

2. var a = new Array();

3. var a = [0,0,0];

   访问元素：数组名+下标

   a[0]   a[3]

   需要注意的是下标从0开始。

   所以在使用的时候需要注意越界的问题，比如5个元素的数组，那么它的下标范围为【0,4】，不包括5,5,已经越界了。

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

数组的常用属性和方法

数组的属性：

length：

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

通过该属性可以改变数组的长度

  数组的常用方法：

unshift：在数组的头部添加元素，返回值返回的是新数组的长度。

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

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

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

push：在数组的尾部插入元素，返回值是添加元素后数组的长度。

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

slice(开始位置的下标，结束位置的下标)：提取数组中指定连续的子数组。

特点是前包括，后不包括。

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

删除操作（可以删除数组中指定的任意元素）；

插入操作（在数组中指定位置插入元素）；

替换查找（在数组中替换指定位置的元素）。

reverse：将数组中的元素，反序输出。在原数组的基础上进行反序输出，不会重新创建新数组。

map：原数组的映射，经过函数的加工，返回给一个新数组。

匿名函数：

一般我们传递的参数都是数值、字符串类型的数据，有些时候可能需要传递一个函数。

vara= [2,4,6,8];
varb=a.map(fun);
functionfun (value,index,self){
   returnvalue*value;
}
alert(b);

将以上内容简写为：

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

数组的应用

1）查找

indexOf系统提供的查找方法

我们也可以自己做一个查找

a.顺序查找

这种查找方法最简单，但是查找次数与数据量成正比效率低

b.折半查找（二分查找）

假设在一个已经有序的数组中，可以利用折半大幅提高效率。

折半查找的最坏查找次数与数据量的关系是对数关系，所以说它的查找效率是很高的，但是任何事情都有两面性，高效率就要有高代价，它的代价就是有序。

2）排序（冒泡排序、选择排序）

3）队列：先进先出，在头部出队（shift），在尾部入队（push）

4）堆栈：先进后出，在尾部进队（push），在尾部出队（pop）