JavaScript数组常用属性方法与技巧

前言

JavaScript数组常用属性方法以及一些常用的技巧的总结。学习中,有错误欢迎指正:)
绝大多数方法参考自MDN - Array
姊妹篇:JavaScript字符串常用方法及技巧

Array

JavaScriptArray是一个用来构造数组的全局对象。

创建数组的两种方法:

Array()构造函数方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
//使用构造函数创建一个数组实例
var myArray = new Array();
//使用构造函数创建一个数组实例并指定长度然后根据下标赋值
var myArray = new Array(7);
myArray[0] = "Sunday";
myArray[1] = "Monday";
myArray[2] = "Tuesday";
myArray[3] = "Wednesday";
myArray[4] = "Thursday";
myArray[5] = "Friday";
myArray[6] = "Saturday";
//使用构造函数直接传入参数创建数组实例并赋值
var myArray = new Array("星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六");

数组字面量方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
//使用数组字面量创建一个数组实例
var myArray = []
//使用数组字面量创建一个数组实例并指定长度然后根据下标赋值
var myArray = [];
myArray[0] = "Sunday";
myArray[1] = "Monday";
myArray[2] = "Tuesday";
myArray[3] = "Wednesday";
myArray[4] = "Thursday";
myArray[5] = "Friday";
myArray[6] = "Saturday";
//使用数组字面量直接传入参数创建数组实例并赋值
var myArray = ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"];

我们可以看出字面量方法更为简洁,直接。而且也更为安全。
当你给Array()构造函数传递一个简单的整数时,它不会成为数组的第一个元素的值,而被用来设置数组的长度;
这意味着new Array(3)会创建一个数组长度为3的数组,但没有实际的元素;

1
2
3
4
5
6
7
var a = [3];
console.log(a.length); // 1
console.log(a[0]); // 3
// an array of three elements
var a = new Array(3);
console.log(a.length); // 3
console.log(typeof a[0]); // "undefined"

虽然这种行为有一点意想不到,但当你传递一个浮点数的时候会变的更糟糕;
会导致一个错误,因为浮点数不是一个合法的值作为数字的长度。

1
2
3
4
5
// using array literal
var a = [3.14];
console.log(a[0]); // 3.14
var a = new Array(3.14); // RangeError: invalid array length
console.log(typeof a); // "undefined"

访问数组元素

1
2
3
4
5
6
var arr = ['a','b','c'];
//通过索引访问数组元素
var first = arr[1];
console.log(first)//a
var last = arr[arr.length-1]
console.log(last)//c

修改数组元素

1
2
3
var arr = ['a','b','c'];
//通过索引修改数组元素
console.log(arr[1])//d

删除数组元素

方法很多,后面介绍数组方法时详细介绍。

数组检测

ECMAScript 5新增了Array.isArray()方法用来判断某个值是否为Array。如果是,则返回true,否则返回false

1
Array.isArray(value)//value是需要检测的值

后面会介绍该方法的兼容性解决方案。

数组属性

Array.prototype

Array.prototype 这个属性表示 Array 的原型对象。所有的数组方法都定义在Array.prototype身上,和其他的构造函数一样,你可以通过扩展Arrayprototype属性上的方法来给所有数组实例增加方法。
还一个鲜为人知的事实:Array.prototype本身也是个数组。

1
Array.isArray(Array.prototype); // true

Array.prototype属性也有两个属性:

Array.prototype.constructor表示 Array 的原型对象的构造函数,它的值就是Array。表明了所有的数组都是由Array函数构造出来的。

Array.prototype.length因为Array.prototype也是个数组,所有它也有length属性,这个值为 0,因为它是个空数组。

array.length

length属性表示一个0到$2^{32} - 1$的整数,返回一个数组实例中的元素个数。

array.constructor

constructor属性返回对创建此对象的构造函数(Array)的引用。

如:

1
2
var a = [];
a.constructor == Array;//true

常用数组方法(不全)

下面介绍一些常用的JavaScript数组方法,一些不常用的或者还未得到主流浏览器支持的方法暂不作介绍。

Array.prototype.concat()

concat()方法将传入的数组或非数组值与原数组合并,组成一个新的数组并返回。
该方法不会改变原数组。
原数组中的元素有两种被拷贝的方式:

  • 对象引用(非对象字面量): concat 方法会复制对象引用放到组合的新数组里,原数组和新数组中的对象引用都指向同一个实际的对象,所以,当实际的对象被修改时,两个数组也同时会被修改.

  • 字符串和数字(是原始值,而不是包装原始值的 StringNumber 对象): concat 方法会复制字符串和数字的值放到新数组里.

语法:

1
arr.concat(value1[, value2[, ...[, valueN]]])

参数:

valueN(必须)需要与原数组合并的数组或非数组值。

返回值:

返回一个新的数组。该数组是通过把所有arrX参数添加到arr中生成的。如果要进行concat()操作的参数是数组,那么添加的是数组中的元素,而不是数组。

例如:

1
2
3
4
var arr = [1,2,3];
var b = arr.concat([4,5],6,7);
console.log(b);//[1,2,3,4,5,6,7]
console.log(arr);//[1,2,3]原数组并没有被改变

Array.prototype.join()

join()方法将数组中的所有元素连接成一个字符串。
该方法不会改变原数组。

语法:

1
arr.join([separator = ','])

参数:

separator(可选)用于指定连接每个数组元素的分隔符。分隔符会被转成字符串类型;如果省略的话,默认为一个逗号。如果seprator是一个空字符串,那么数组中的所有元素将被直接连接。

返回值:

返回一个字符串。该字符串是通过把arr的每个元素转换为字符串,然后把这些字符串连接起来,在元素之间插入separator字符串而生成的。

例如:

1
2
3
4
var arr = [1,2,3];
var str = arr.join("-");
console.log(str);//1-2-3
console.log(arr);//[1,2,3]原数组并没有被改变

Array.prototype.reverse()

reverse()方法用于颠倒数组中元素的顺序。
该方法会改变原数组。

语法:

1
arr.reverse()

参数:

无。

返回值:

返回修改过后的原数组的引用。

例如:

1
2
3
4
var arr = [1,2,3];
var b = arr.reverse();
console.log(arr);//[3,2,1]原数组已经被修改
console.log(b);//[3,2,1]返回值是修改过后的原数组的引用

Array.prototype.sort()

sort()方法用于对数组的元素进行排序。
该方法会改变原数组。

语法:

1
arr.sort([compareFunction])

参数:

compareFunction(可选)用来指定按某种顺序进行排列的函数。

如果省略,元素按照转换为的字符串的诸个字符的Unicode位点进行排序。例如 “Banana” 会被排列到 “cherry” 之前。数字比大小时,9 出现在 80 之前,但这里比较时数字会先被转换为字符串,所以 “80” 比 “9” 要靠前。

如果指明了compareFunction,那么数组会按照调用该函数的返回值排序。记 a 和 b 是两个将要被比较的元素:

如果compareFunction(a, b)小于 0 ,那么 a 会被排列到 b 之前。
如果 compareFunction(a, b)等于 0 , ab 的相对位置不变。
如果 compareFunction(a, b) 大于 0b 会被排列到 a 之前。
compareFunction(a, b)必须总是对相同的输入返回相同的比较结果,否则排序的结果将是不确定的。

返回值:

返回修改过的原数组的引用。

例如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var arr = new Array(6)
arr[0] = "10"
arr[1] = "5"
arr[2] = "40"
arr[3] = "25"
arr[4] = "1000"
arr[5] = "1"
// 比较函数
function sortNumber(a,b)
{
return a - b
}
console.log(arr);//["10", "5", "40", "25", "1000", "1"]
console.log(arr.sort());//["1", "10", "1000", "25", "40", "5"]直接调用sort()方法并没有得到我们想要的结果
console.log(arr.sort(sortNumber));//["1", "5", "10", "25", "40", "1000"]
console.log(arr);//["1", "5", "10", "25", "40", "1000"]原数组已被修改

Array.prototype.slice()

slice()方法会浅复制(shallow copy)数组的一部分到一个新的数组,并返回这个新数组。
该方法不会改变原数组。

语法:

1
arr.slice([start[, end]])

参数:

start(可选)从该索引处开始提取原数组中的元素(默认从0开始)。如果该参数为负数,则表示从原数组中的倒数第几个元素开始提取。

end(可选)在该索引处结束提取原数组元素。如果该参数为负数,则它表示在原数组中的倒数第几个元素结束抽取。如果被省略,则slice会一直提取到原数组末尾。

如果 start 大于 end 则提取到的数组为空数组。

返回值:

返回一个新的数组,包含从startend(不包括该元素)的arr中的元素。

例如:

1
2
3
4
var arr = [1,2,3];
var b = arr.slice(1,2);
console.log(b);//[2]返回新数组
console.log(arr);//[1,2,3]原数组并未被修改

Array.prototype.splice()

splice()方法用新元素替换旧元素,以此修改数组的内容。
该方法会改变原数组。

语法:

1
array.splice(start, deleteCount[, item1[, item2[, ...]]])

参数:

start(必须)从数组的哪一位开始修改内容。如果超出了数组的长度,则从数组末尾开始添加内容;如果是负值,则表示从数组末位开始的第几位。

deleteCount(必须)整数,表示要移除的数组元素的个数。如果 deleteCount0,则不移除元素。这种情况下,至少应添加一个新元素。如果 deleteCount 大于 start 之后的元素的总数,则从 start 后面的元素都将被删除(含第 start 位)。

itemN(可选)要添加进数组的元素。如果不指定,则 splice() 只删除数组元素。

返回值:

返回一个新的数组,由被删除的元素组成的一个数组。如果只删除了一个元素,则返回只包含一个元素的数组。如果没有删除元素,则返回空数组。

例如:

1
2
3
4
5
var arr = [1,2,3,4,5];
//从索引1开始删除2个元素并插入'a','b'两个元素
var b = arr.splice(1,2,'a','b');
console.log(b);//[2,3]返回被删除元素组成的数组
console.log(arr);//[1,'a','b',4,5]原数组已被修改

Array.prototype.pop()

pop()方法删除一个数组中的最后的一个元素,并且返回这个元素。
该方法会改变原数组。

语法:

1
arr.pop()

参数:

无。

返回值:

返回被删除的元素。

例如:

1
2
3
4
var arr = [1,2,3,4,5];
var b = arr.pop();
console.log(b);//5返回被删除的元素
console.log(arr);//[1,2,3,4]原数组已被修改

Array.prototype.push()

push()方法添加一个或多个元素到数组的末尾,并返回数组新的长度(length 属性值)。
该方法会改变原数组。

语法:

1
arr.push(element1, ..., elementN)

参数:

elementN(必须)被添加到数组末尾的元素,至少一个。

返回值:

返回数组新的长度(length 属性值)。

例如:

1
2
3
4
var arr = [1,2,3,4,5];
var b = arr.push('a','b');
console.log(b);//7返回原数组新的长度
console.log(arr);//[1,2,3,4,'a','b']原数组已被修改

Array.prototype.shift()

shift()方法删除一个数组中的最后的一个元素,并且返回这个元素。
该方法会改变原数组。

语法:

1
arr.shift()

参数:

无。

返回值:

返回被删除的元素。

例如:

1
2
3
4
var arr = [1,2,3,4,5];
var b = arr.pop();
console.log(b);//1返回被删除的元素
console.log(arr);//[2,3,4,5]原数组已被修改

Array.prototype.unshift()

push()方法添加一个或多个元素到数组的开头,并返回数组新的长度(length 属性值)。
该方法会改变原数组。

语法:

1
arr.unshift(element1, ..., elementN)

参数:

elementN(必须)被添加到数组开头的元素,至少一个。

返回值:

返回数组新的长度(length 属性值)。

例如:

1
2
3
4
var arr = [1,2,3,4,5];
var b = arr.unshift('a','b');
console.log(b);//7返回原数组新的长度
console.log(arr);//['a','b',1,2,3,4]原数组已被修改

Array.prototype.toString()

toString()方法可把数组转换为字符串,并返回结果。
当数组用于字符串环境时,JavaScript 会调用这一方法将数组自动转换成字符串。但是在某些情况下,需要显式地调用该方法。
该方法不会改变原数组。

语法:

1
arr.toString()

参数:

无。

返回值:

arr的字符串表示。返回值与没有参数的 join() 方法返回的字符串相同。

例如:

1
2
3
4
var arr = [1,2,3,4,5];
var b = arr.toString();
console.log(b);//1,2,3,4,5
console.log(arr);//[1,2,3,4,5]原数组未被修改

Array.prototype.indexOf()

indexOf()方法返回指定元素能找在数组中找到的第一个索引值,否则返回 -1

语法:

1
arr.indexOf(searchElement[, fromIndex])

参数:

searchElement(必须)要查找的元素。

fromIndex(可选)开始查找的位置。如果该索引值大于或等于数组长度,意味着不会在数组里查找,返回-1。如果参数中提供的索引值是一个负值,则将其作为数组末尾的一个抵消,如果抵消后的索引值仍小于0,则整个数组都将会被查询。其默认值为0。

返回值:

返回值定元素能找在数组中找到的第一个索引值。

例如:

1
2
3
4
5
6
var array = [2, 5, 9];
array.indexOf(2); // 0
array.indexOf(7); // -1
array.indexOf(9, 2); // 2
array.indexOf(2, -1); // -1
array.indexOf(2, -3); // 0

Array.prototype.lastIndexOf()

lastIndexOf()方法返回指定元素在数组中的最后一个的索引值,如果不存在则返回 -1 。从数组的后面向前查找,从 fromIndex 处开始。

语法:

1
arr.lastIndexOf(searchElement[, fromIndex])

参数:

searchElement(必须)要查找的元素。

fromIndex(可选)从此位置开始逆向查找。如果该索引值大于或等于数组长度,则整个数组会被查找。如果为负值,将其视为从数组末尾向前的偏移。如果其绝对值大于数组长度,则方法返回 -1。默认为数组的长度减 1,即整个数组都被查找。

返回值:

返回值定元素能找在数组中找到的最后一个索引值。

例如:

1
2
3
4
5
6
7
var array = [2, 5, 9, 2];
array.lastIndexOf(2); // 3
array.lastIndexOf(7); // -1
array.lastIndexOf(2, 3); // 3
array.lastIndexOf(2, 2); // 0
array.lastIndexOf(2, -2); // 0
array.lastIndexOf(2, -1); // 3

Array.prototype.forEach()

forEach()方法按升序让数组的每一项都执行一次给定的 callback 函数。那些已删除(使用 delete 方法等情况)或者从未赋值的项将被跳过(但不包括那些值为 undefined 的项)。

语法:

1
array.forEach(callback[, thisArg])

参数:

callback(必须)在数组每一项上执行的函数,接收三个参数:

currentValue当前项(指遍历时正在被处理那个数组项)的值。
index当前项的索引(或下标)。
array数组本身。

thisArg(可选)用来当作 callback 函数内 this 的值的对象。
如果给 forEach 传递了 thisArg 参数,它将作为 callback 函数的执行上下文,类似执行如下函数 callback.call(thisArg, element, index, array)

返回值:

undefined。

例如:

1
2
3
4
5
6
7
8
function logArrayElements(element, index, array) {
console.log("a[" + index + "] = " + element);
}
[2, 5, 9].forEach(logArrayElements);
// logs:
// a[0] = 2
// a[1] = 5
// a[2] = 9

等同于下面这个传统的 for 循环:

1
2
3
4
5
var arr = [2, 5, 9];
for(var i = 0; i < arr.length; i++){
console.log("arr[" + i + "] = " + arr[i])
}

浏览器支持:IE9+

兼容性处理:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
if (!Array.prototype.forEach) {
Array.prototype.forEach = function(callback, thisArg) {
var T, k;
if (this == null) {
throw new TypeError(' this is null or not defined');
}
var O = Object(this);
var len = O.length >>> 0;
if (typeof callback !== "function") {
throw new TypeError(callback + ' is not a function');
}
if (arguments.length > 1) {
T = thisArg;
}
k = 0;
while (k < len) {
var kValue;
if (k in O) {
kValue = O[k];
callback.call(T, kValue, k, O);
}
k++;
}
};
}

Array.prototype.map()

map()方法返回一个由原数组中的每个元素调用一个指定方法后的返回值组成的新数组。 callback 函数只会在有值的索引上被调用;那些从来没被赋过值或者使用 delete 删除的索引则不会被调用。
map不修改调用它的原数组本身(当然可以在 callback 执行时改变原数组)。

语法:

1
array.forEach(callback[, thisArg])

参数:

callback(必须)在数组每一项上执行的函数,接收三个参数:

currentValue当前项(指遍历时正在被处理那个数组项)的值。
index当前项的索引(或下标)。
array数组本身。

thisArg(可选)用来当作 callback 函数内 this 的值的对象。
如果给 forEach 传递了 thisArg 参数,它将作为 callback 函数的执行上下文,类似执行如下函数 callback.call(thisArg, element, index, array)

返回值:

返回一个新的数组。该数组由原数组中的每个元素调用一个指定方法后的返回值组成。

例如:

1
2
3
4
// 求数组中每个元素的平方根
var numbers = [1, 4, 9];
var roots = numbers.map(Math.sqrt);
/* roots的值为[1, 2, 3], numbers的值仍为[1, 4, 9] */// a[2] = 9

在字符串上使用 map 方法:

1
2
3
// 在一个 String 上使用 map 方法获取字符串中每个字符所对应的 ASCII 码组成的数组
var a = Array.prototypemap.call("Hello World", function(x) { return x.charCodeAt(0); })
// a的值为[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]

易错点:

通常情况下,map 方法中的 callback 函数只需要接受一个参数,就是正在被遍历的数组元素本身。但这并不意味着 map 只给 callback 传了一个参数(事实上是三个)。这个思维惯性可能会让我们犯一个很容易犯的错误。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 下面的语句返回什么呢:
["1", "2", "3"].map(parseInt);
// 你可能觉的会是[1, 2, 3]
// 但实际的结果是 [1, NaN, NaN]
// 通常使用parseInt时,只需要传递一个参数.但实际上,parseInt可以有两个参数.第二个参数是进制数.可以通过语句"alert(parseInt.length)===2"来验证.
// map方法在调用callback函数时,会给它传递三个参数:当前正在遍历的元素, 元素索引, 原数组本身.
// 第三个参数parseInt会忽视, 但第二个参数不会,也就是说,parseInt把传过来的索引值当成进制数来使用.从而返回了NaN.
/*
//应该使用如下的用户函数returnInt
function returnInt(element){
return parseInt(element,10);
}
["1", "2", "3"].map(returnInt);
// 返回[1,2,3]
*/

浏览器支持:IE9+

兼容性处理:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
if (!Array.prototype.map) {
Array.prototype.map = function(callback, thisArg) {
var T, A, k;
if (this == null) {
throw new TypeError(" this is null or not defined");
}
// 1. 将O赋值为调用map方法的数组.
var O = Object(this);
// 2.将len赋值为数组O的长度.
var len = O.length >>> 0;
// 3.如果callback不是函数,则抛出TypeError异常.
if (Object.prototype.toString.call(callback) != "[object Function]") {
throw new TypeError(callback + " is not a function");
}
// 4. 如果参数thisArg有值,则将T赋值为thisArg;否则T为undefined.
if (thisArg) {
T = thisArg;
}
// 5. 创建新数组A,长度为原数组O长度len
A = new Array(len);
// 6. 将k赋值为0
k = 0;
// 7. 当 k < len 时,执行循环.
while (k < len) {
var kValue, mappedValue;
//遍历O,k为原数组索引
if (k in O) {
//kValue为索引k对应的值.
kValue = O[k];
// 执行callback,this指向T,参数有三个.分别是kValue:值,k:索引,O:原数组.
mappedValue = callback.call(T, kValue, k, O);
// 返回值添加到新数组A中.
A[k] = mappedValue;
}
// k自增1
k++;
}
// 8. 返回新数组A
return A;
};
}

Array.prototype.filter()

filter()方法使用指定的函数测试所有元素,并创建一个包含所有通过测试的元素的新数组。
filter为“过滤”、“筛选”之意。指数组filter后,返回过滤后的新数组。用法跟map极为相似:

语法:

1
array.filter(callback[, thisArg])

参数:

callback(必须)用来测试数组的每个元素的函数。调用时使用参数 (element, index, array)。
返回 true 表示保留该元素(通过测试), false 则不保留。
返回值只要是弱等于 == true/false 就可以了,而非非得返回 === true/false

thisArg(可选)执行 callback 时的用于 this 的值。

返回值:

返回一个新的数组,内容为原数组通过 filter 函数的元素。

例如:

1
2
3
4
5
function isBigEnough(element) {
return element >= 10;
}
var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
// filtered is [12, 130, 44]

浏览器支持:IE9+

兼容性处理:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
if (!Array.prototype.filter) {
Array.prototype.filter = function(fun /*, thisArg */ ) {
"use strict";
if (this === void 0 || this === null)
throw new TypeError();
var t = Object(this);
var len = t.length >>> 0;
if (typeof fun !== "function")
throw new TypeError();
var res = [];
var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
for (var i = 0; i < len; i++) {
if (i in t) {
var val = t[i];
if (fun.call(thisArg, val, i, t))
res.push(val);
}
}
return res;
};
}

Array.prototype.every()

every()方法测试数组的所有元素是否都通过了指定函数的测试。

语法:

1
arr.every(callback[, thisArg])

参数:

callback(必须)用来测试数组的每个元素的函数。

thisArg(可选)执行 callback 时的用于 this 的值。

返回值:

返回一个布尔值。every 方法为数组中的每个元素执行一次 callback 函数,直到它找到一个使 callback 返回一个”假值“(表示可转换为布尔值 false 的值)的元素。如果发现了一个这样的元素,every 方法将会立即返回 false。否则,callback 为每一个元素返回 trueevery 就会返回 true

例如:

1
2
3
4
5
6
7
8
// 检测数组中的所有元素是否都大于 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

浏览器支持:IE9+

兼容性处理:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
if (!Array.prototype.every)
{
Array.prototype.every = function(fun /*, thisArg */)
{
'use strict';
if (this === void 0 || this === null)
throw new TypeError();
var t = Object(this);
var len = t.length >>> 0;
if (typeof fun !== 'function')
throw new TypeError();
var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
for (var i = 0; i < len; i++)
{
if (i in t && !fun.call(thisArg, t[i], i, t))
return false;
}
return true;
};
}

Array.prototype.some()

some()方法测试数组中的某些元素是否通过了指定函数的测试。

语法:

1
arr.some(callback[, thisArg])

参数:

callback(必须)用来测试数组的每个元素的函数。

thisArg(可选)执行 callback 时的用于 this 的值。

返回值:

返回一个布尔值。some 为数组中的每一个元素执行一次 callback 函数,直到找到一个使得 callback 返回一个“真值”(即可转换为布尔值 true 的值)。如果找到了这样一个值,some 将会立即返回 true。否则,some 返回 false

例如:

1
2
3
4
5
6
7
8
// 检测数组中的所有元素是否都大于 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

浏览器支持:IE9+

兼容性处理:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
if (!Array.prototype.every)
{
Array.prototype.every = function(fun /*, thisArg */)
{
'use strict';
if (this === void 0 || this === null)
throw new TypeError();
var t = Object(this);
var len = t.length >>> 0;
if (typeof fun !== 'function')
throw new TypeError();
var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
for (var i = 0; i < len; i++)
{
if (i in t && !fun.call(thisArg, t[i], i, t))
return false;
}
return true;
};
}

Array.isArray()

上面提到过Array.isArray()方法用来判断某个值是否为Array

语法:

1
Array.isArray(value)

参数:

value(必须)是需要检测的值。

返回值:

返回一个布尔值。如果是,则返回true,否则返回false

浏览器支持:

兼容性处理:

1
2
3
4
5
if (!Array.isArray) {
Array.isArray = function(arg) {
return Object.prototype.toString.call(arg) === '[object Array]';
};
}

数组常用技巧

参考来源

Array - MDN
JavaScript Array 对象 - W3C
JavaScript学习笔记(六) 数组字面量和Array()构造方法
ES5中新增的Array方法详细说明