Javascript 数组

1、数组的创建

var arr1 = new Array();　//创建一个数组
var arr2 = new Array(5);　//创建一个数组并指定长度，注意不是上限，是长度
var arr3 = new Array(1,3,5,7,9);　//创建一个数组并赋值
var arr4 = [2,4,6,8,10];

要说明的是，虽然第二种方法创建数组指定了长度，但实际上所有情况下数组都是变长的，也就是说即使指定了长度为5，仍然可以将元素存储在规定长度以外的，注意：这时长度会随之改变。

2、数组的元素的访问

var testGetArrValue=arrayObj[1]; //获取数组的元素值
arrayObj[1]= "这是新值"; //给数组元素赋予新的值

3、数组元素的字符串化

arrayObj.join(separator); 返回字符串，这个字符串将数组的每一个元素值连接在一起，中间用 separator 隔开。

var arr = new Array(1,3,5,7,9);
arr.join("-");   //输出1-3-5-7-9

3、数组元素的添加

arrayObj. push([item1 [item2 [. . . [itemN ]]]]);// 将一个或多个新元素添加到数组结尾，并返回数组新长度

arrayObj.unshift([item1 [item2 [. . . [itemN ]]]]);// 将一个或多个新元素添加到数组开始，数组中的元素自动后移，返回数组新长度

arrayObj.splice(insertPos,0,[item1[, item2[, . . . [,itemN]]]]);//将一个或多个新元素插入到数组的指定位置，插入位置的元素自动后移，返回""。

var arr = new Array(1,3,5,7,9);
document.writeln(arr.join("-"));   //输出1-3-5-7-9
alert(arr.push(11)); //在末尾添加
document.writeln(arr.join("-"));   //输出1-3-5-7-9-11
arr.unshift(0); //在头部添加
document.writeln(arr.join("-"));   //输出0-1-3-5-7-9-11
arr.splice(2,0,2,4);  //在位置为2之后插入数据2和4
document.writeln(arr.join("-"));   //输出0-1-2-4-3-5-7-9-11

4、splice用法

javascript 中的

splice

方法很强大，它可以用于插入、删除或替换数组的元素。
下面来一一介绍！

删除：用于删除元素，两个参数，第一个参数（要删除第一项的位置），第二个参数（要删除的项数）

插入：向数组指定位置插入任意项元素。三个参数，第一个参数（其实位置），第二个参数（0），第三个参数（插入的项）

替换：向数组指定位置插入任意项元素，同时删除任意数量的项，三个参数。第一个参数（起始位置），第二个参数（删除的项数），第三个参数（插入任意数量的项）

splice方法返回一个数组，该数组包含删除的项目，如果没有删除的项目，则返回一个空数组

var lang = ["php","java","javascript"];
//删除
var removed = lang.splice(1,1);
alert(lang); //php,javascript
alert(removed); //java ,返回删除的项
//插入
var insert = lang.splice(0,0,"asp"); //从第0个位置开始插入
alert(insert); //返回空数组
alert(lang); //asp,php,javascript
//替换
var replace = lang.splice(1,1,"c#","ruby"); //删除一项，插入两项
alert(lang); //asp,c#,ruby,javascript
alert(replace); //php,返回删除的项

5、数组元素的删除

arrayObj.pop(); //移除最后一个元素并返回该元素值

arrayObj.shift(); //移除最前一个元素并返回该元素值，数组中元素自动前移

arrayObj.splice(deletePos,deleteCount); //删除从指定位置deletePos开始的指定数量deleteCount的元素，数组形式返回所移除的元素

6、数组的截取和合并

arrayObj.slice(start, [end]); //以数组的形式返回数组的一部分，注意不包括 end 对应的元素，如果省略 end 将复制 start 之后的所有元素

arrayObj.concat([item1[, item2[, . . . [,itemN]]]]); //将多个数组（也可以是字符串，或者是数组和字符串的混合）连接为一个数组，返回连接好的新的数组

7、数组的拷贝

arrayObj.slice(0); //返回数组的拷贝数组，注意是一个新的数组，不是指向

arrayObj.concat(); //返回数组的拷贝数组，注意是一个新的数组，不是指向

8、数组元素的排序

arrayObj.reverse(); //反转元素（最前的排到最后、最后的排到最前），返回数组地址

arrayObj.sort(); //对数组元素排序，返回数组地址

下面看看sort方法：

var arr=[3,1,4,10,5];
alert(arr) //输出 3,1,4,10,5

arr.sort();
alert(arr); //输出1,10,3,4,5

这里对数组排序后的结果，并没有按照数字大小进行排序，将数组元素看成一个字符串，每次取字符串的一位进行比较。 如果要按照数字的自然大小进行排序，那么需要自定义排序方式

var arr=[3,1,4,10,5];

function compare(val1,val2){
if(val1<val2){
return -1;
}else if(val1>val2){
return 1;
}else {
return 0;
}
}

arr.sort(compare);

alert(arr);  //输出结果：1,3,4,5,10

这是升序的方式，降序方法类似

filter():

语法：

var filteredArray = array.filter(callback[, thisObject]);

参数说明：

callback： 要对每个数组元素执行的回调函数。
thisObject ： 在执行回调函数时定义的this对象。

//过滤掉小于 10 的数组元素：

//代码：
function isBigEnough(element, index, array) {
return (element >= 10);
}
var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
// 12, 130, 44
//结果：[12, 5, 8, 130, 44].filter(isBigEnough) ： 12, 130, 44

功能说明：

对数组中的每个元素都执行一次指定的函数（callback），并且创建一个新的数组，该数组元素是所有回调函数执行时返回值为 true 的原数组元素。它只对数组中的非空元素执行指定的函数，没有赋值或者已经删除的元素将被忽略，同时，新创建的数组也不会包含这些元素。

回调函数可以有三个参数：当前元素，当前元素的索引和当前的数组对象。

如参数 thisObject 被传递进来，它将被当做回调函数（callback）内部的 this 对象，如果没有传递或者为null，那么将会使用全局对象。

filter 不会改变原有数组，记住：只有在回调函数执行前传入的数组元素才有效，在回调函数开始执行后才添加的元素将被忽略，而在回调函数开始执行到最后一个元素这一期间，数组元素被删除或者被更改的，将以回调函数访问到该元素的时间为准，被删除的元素将被忽略。

map():

//将所有的数组元素转换为大写：

var strings = ["hello", "Array", "WORLD"];
function makeUpperCase(v)
{
return v.toUpperCase();
}
var uppers = strings.map(makeUpperCase);
// uppers is now ["HELLO", "ARRAY", "WORLD"]
// strings is unchanged
//结果：["hello", "Array", "WORLD"].map(makeUpperCase) ： HELLO, ARRAY, WORLD

some():

对数组中的每个元素都执行一次指定的函数（callback），直到此函数返回 [b]true，如果发现这个元素，some 将返回 true，如果回调函数对每个元素执行后都返回 false ，some 将返回 false。它只对数组中的非空元素执行指定的函数，没有赋值或者已经删除的元素将被忽略。[/b]

//检查是否有数组元素大于等于10：

function isBigEnough(element, index, array) {
return (element >= 10);
}
var passed = [2, 5, 8, 1, 4].some(isBigEnough);
// passed is false
passed = [12, 5, 8, 1, 4].some(isBigEnough);
// passed is true
//结果：
//[2, 5, 8, 1, 4].some(isBigEnough) ： false
//[12, 5, 8, 1, 4].some(isBigEnough) ： true

every():

对数组中的每个元素都执行一次指定的函数（callback），直到此函数返回 [b]false，如果发现这个元素，every 将返回 false，如果回调函数对每个元素执行后都返回 true ，every 将返回 true。它只对数组中的非空元素执行指定的函数，没有赋值或者已经删除的元素将被忽略[/b]

//测试是否所有数组元素都大于等于10：

function isBigEnough(element, index, array) {
return (element >= 10);
}
var passed = [12, 5, 8, 130, 44].every(isBigEnough);
// passed is false
passed = [12, 54, 18, 130, 44].every(isBigEnough);
// passed is true
//结果：
//[12, 5, 8, 130, 44].every(isBigEnough) 返回 ： false
//[12, 54, 18, 130, 44].every(isBigEnough) 返回 ： true

forEach():

//打印数组内容：

function printElt(element, index, array) {
document.writeln("[" + index + "] is " + element + "<br />");
}
[2, 5, 9].forEach(printElt);
// Prints:
// [0] is 2
// [1] is 5
// [2] is 9
//结果：
//[0] is 2
//[1] is 5
//[2] is 9

lastIndexOf():

语法

var index = array.lastIndexOf(searchElement[, fromIndex]);

参数说明

searchElement： 要搜索的元素

fromIndex ： 开始搜索的位置，默认为数组的长度（length），在这样的情况下，将搜索所有的数组元素。搜索是反方向进行的。

功能说明

比较 searchElement 和数组的每个元素是否绝对一致（===），当有元素符合条件时，返回当前元素的索引。如果没有发现，就直接返回 -1 。

//查找符合条件的元素：

var array = [2, 5, 9, 2];
var index = array.lastIndexOf(2);
// index is 3
index = array.lastIndexOf(7);
// index is -1
index = array.lastIndexOf(2, 3);
// index is 3
index = array.lastIndexOf(2, 2);
// index is 0
index = array.lastIndexOf(2, -2);
// index is 0
index = array.lastIndexOf(2, -1);
// index is 3
//结果：
//[2, 5, 9, 2].lastIndexOf(2) ： 3
//[2, 5, 9, 2].lastIndexOf(7) ： -1
//[2, 5, 9, 2].lastIndexOf(2, 3) ： 3
//[2, 5, 9, 2].lastIndexOf(2, 2) ： 0
//[2, 5, 9, 2].lastIndexOf(2, -2) ： 0
//[2, 5, 9, 2].lastIndexOf(2, -1) ： 3

indexOf():

功能与lastIndexOf()一样，搜索是正向进行的

//查找符合条件的元素：

var array = [2, 5, 9];
var index = array.indexOf(2);
// index is 0
index = array.indexOf(7);
// index is -1
//结果：
//[2, 5, 9].indexOf(2) ： 0
//[2, 5, 9].indexOf(7) ： -1