javascript数组的基本使用方法

1.数组有这样几种方式来创建

var array = new Array();

var array = new Array()10;//指定长度

var array = new Array(“one”,”two”,”three”);

常用方法有这些：

concat()---连接两个或更多的数组，并返回结果
join()---把数组的所有元素放入一个字符串，元素通过指定的分隔符进行分割
pop()---删除并返回数组的最后一个元素
push()---向数组的末尾添加一个或更多元素，并返回新的长度
reverse()---颠倒数组中元素的顺序
shift()---删除并返回数组的第一个元素
slice()---从某个已有的数组返回选定的元素
sort()---对数组的元素进行排序
splice()---删除数组，并向数组添加新元素
unshift()---向数组开头添加一个或更多元素，并返回新的长度
valueOf()---返回数组对象的原始值

下面我们通过一些实际的例子来说明数组的使用(主要方法的使用):

var array = [];

array.push(1);

array.push(2);

array.push(“three”);

array.push(“four”);

array.push(3.14);

push方法可以向数组中添加元素。

Javascript数组没用数据类型的限制，可以向数组里添加任何类型的元素

var len = array.length;//获取数组的长度

for(var i = 0; i < len; i++){

alert(typeof arrayp[i]);

}

结果为：

number

number

string

string

number

弹出数组中的元素:

for(var i = 0; i < len; i++){

alert(array.pop());

}

alert(array.length);

运行结果如下，注意最后0是指array的长度，因为这时数组的内容已经全部弹出：

3.14

four

three

2

1

0

join：连接数组元素为一个字符串

array = ["one","two","three","four","five"]

var str1 = array.join("|");

var str2= array.join(",");

运行结果：

one|two|three|four|five

one,two,three,four,five

连接多个数组为一个数组：

var anthor = [1,2,3,4];

var anthor2 = [5,6,7,8];

var newArray = array.concat(anthor,anthor2);

结果为：

one,two,three,four,five,1,2,3,4,5,6,7,8

从数组中取出一定数量的元素，不影响数组本身：

alert(newArray.slice(5,9);

结果为：

1，2，3，4

slice方法的第一个参数为起始位置，第二个参数为终止位置，操作不影响数组本身。

下面我们来看splice方法，虽然这两个方法拼写非常相似，但功能完全不同，splice是一个相当难用的方法：

newArray.splice(5,2);

newArray.splice(5,0,”haha”,”hehe”,”heihei”);

第一行代码表示，从newArray数组中，从第5个元素起，删除2个元素，而第二行代码则表示，从第5个元素起，删除0个元素，并且把随后的所有参数插入到从第5个开始的位置。

我们再来讨论下数组的排序，Javascript数组的排序函数sort，将数组按字母顺序排序，排序过程会影响源数组，比如：

var array = ["cisio","borland","apple","dell"]
alert(array);
array.sort();
alert(array);

执行结果为：

cisio,borland,apple,dell

apple,borland,cisio,dell

这些字母排序的方式会造成一些非你所预想的小bug，比如：

var array = [10,23,44,58,106,235];

array.sort();
alert(array);

得到的结果为：

10，106，23，235，44，58

可以看出，javascript中的sort不关注数组中的内容是字母还是数字，它仅仅是按照字母的字典序来进行排序，对于这种情况，Javascript提供了另一种途径，通过给sort传递一个函数对象，按照这个函数提供的规则对数组进行排序。

function sorter(a,b){
	return a - b;
}
var array = [10,23,44,58,106,235];
array.sort(sorter);
alert(array);

函数sorter接受两个参数，返回一个数值，如果这个值大于0，则说明第一个参数大于第二个参数，如果返回值为0，则说明两个参数相等，返回值小于0，则第一个参数小于第二个参数，sort根据这个返回值来进行最终排序：

则运行结果是：

10，23，44，58，106，235

当然，也可以简写成这样：

array.sort(function(a,b){return a - b});//正序
array.sort(function(a,b){return b - a});//逆序

删除数组元素：

虽然令人费解，但是Javascript的数组对象确实没有一个叫做delete或remove的方法，这就需要我们自己扩展其数组对象。通常，我们可以扩展javascript解释器环境中的内置对象，这中方式的好处在于，扩张之后的对象可以适用于其后的任意场景，而不用每次都显示的声明；而这种做法的坏处在于，修改了内置对象，则可能出现一些难以预料的错误，比如遍历数组的时候，可能会产生令人费解的异常。

数组中的每个元素都是一个对象，那么，我们可以使用delete来删除元素吗？来看看下面的小例子吧：

var array = ["one","two","three","four","five"];
alert(array.length);
delete array[2];
alert(array);
alert(array.length);

然后我们看看运行之后的结果是怎样的：

5
one,two,undefine,four,five
5

可以看出，delete只是将数组array的第三个位置上的元素删掉了，可是数组的长度却没有改变，显然不是我们想要的结果，不过我们可以借助数组自身的slice方法来做到。

一个比较好的实现，来自于jquery的设计中John Resig:

Array.prototype.remove = function(from, to){
	var rest = this.slice((to || from) + 1 || this.length);
	this.length = from < 0 ? this.length + from : from;
	return this.push.apply(this,rest);
}

这个函数扩展了Javascript的内置对象Array，这样，我们以后的所有声明的数组都会自动拥有这个remove功能，我们来看看这个方法的用法：

var array = ["one","two","three","four","five","six"];
alert(array);
array.remove(0);//删除第一个元素
alert(array);
array.remove(-1);//删除倒数第一个元素
alert(array);
array.remove(0,2);//删除数组中下标为0-2的元素(3个)
alert(array);

得到下面的结果：

one,two,three,four,five,six
two,three,four,five,six
two,three,four,five
five

也就是说，remove接受两个参数，第一个参数为起始下标，第二个参数为结束下标，其中第二个参数可以忽略，这种情况下会删除指定下标的元素。

当然，不是每个人都希望影响整个原型链(下面有介绍)此可以考虑另一种方式：

Array.remove = function(array,from, to){
	var rest = array.slice((to || from) + 1 || array.length);
	array.length = from < 0 ? array.length + from : from;
	return array.push.apply(array.rest);
}

其操作方式与前者无二异，但是不影响全局对象，代价是你需要显示的传递需要操作的数组作为第一个参数：

var array = ["one","two","three","four","five","six"];
Array.remove(array,0,2);//删除0，1，2三个元素
alert(array);

这种方式相当于给Javascrip内置的Array添加了一个静态方法.

遍历数组：

1.for…in 循环

var array = [1,2,3,4];
for(var item in array){
	alert(array[item]);
}

将会打印：

1
2
3
4

但是这种方式并不总是有效，比如我们扩张了内置对象Array，如下：

Array.prototype.useless = function(){}

然后重复执行上面的代码，会得到这样的输出结果：

1
2
3
4
function(){}

设想这样一种情况，如果你对数组的遍历做sum操作，那么会得到一个莫名其妙的错误，毕竟函数对象不能做求和操作。幸运的是，我们可以使用另一种方式来取得正确的结果：

for(var i = 0; i < array.length; i++){
	alert(array[i]);
}
这种for循环如其他很多语言中的写法一致，重要的是，它不会访问那些下标不是数字的元素，如上例的function，这个function的下标为useless，是一个字符串。从这个例子中可以看出，除非必要，尽量不要去扩展全局对象，因为对全局对象的扩展会造成所有继承链上都带上“烙印”，而有时候这些烙印会成为滋生bug的温床。