创建数组
使用字面量语法和Array()构造函数。
字面量
使用数组字面量是创建数组最简单的方法,在方括号内将数组元素用都好隔开即可。
var s = [];//空数组
var s = [1,1,1,1,1]//有5个值的数组。
虽然javascript数组与其他语言中数组都是数据的有序列表,但是与其他语言不同的是,js的每一项可以保留任何类型的数据。
var s = [1,true,'a'];
数组字面量不一定是常量,它可以是任意表达式。
var base = 1024;
var table = [base,base+1,base+2,base+3];
可以包含对象字面量或者其他数组字面量。
var s = [[1,{a:2,y:3}],[2,{w:8,r:7}]];
如果数组的元素还是数组,就是多维数组。
var s = [[1, 2], [3, 4]];
使用数字字面量表示法时,不会调用Array构造函数。
函数构造
有三种方式调用构造函数
1:没有参数,创建一个空数组。
//该方法用于创建一个空数组,相当于[];
var s = new Array();
2: 有一个参数,该参数用于指定数组的长度。
var s = new Array(10);
console.log(s);//[];
console.log(a[0],a.length);//undefined 10
3: 如存在 一个其他的类型的参数,则会创建一个含那个值的只有一项的数组。
var s = new Array('10');
console.log(s);//['10']
console.log(s.length);//1
4: 有多个参数的时候参数代表具体的数组元素,
var a = new Array(1,2,3);
console.log(a);//[1,2,3]
console.log(a[0],a[1],a[2]);//1 2 3
5:使用Array构造函数时,可以省略new操作符号。
var a1 = Array();
var a2 = Array(10);
var a3 = Array(1,2,3);
console.log(a1,a2,a3);//[] [] [1,2,3]
数组本质
数组是按次序排列的一组值,本质上数组是一种特殊的对象。
typeof [1,2,4];// object;
数组的特殊性体现在,它的键名是按次序排列的一组整数(0,1,2,3);由于数组成员的键名是固定的,应次数组不用为每个元素指定键名。而对象的每个成员都必须指定键名。
var s = [1,2,3,5];
console.log(Object.key(s));// ["0", "1", "2"];
var obj = {
name1: 'a',
name2: 'b',
name3: 'c'
};
数组是对象的特殊形式,使用方括号访问数组元素,就像方括号访问对象的属性一样。
js语言规定,对象的键名一律为字符串,所以,数组的键名其实也是字符串,之所有可以用数组来读取,是因为非字符串的键名会被转为字符串,然后,将其作为属性名来使用。
o={}; //创建一个普通的对象
o[1]="one"; //用一个整数来索引它
//数值键名被自动转成字符串
var arr = ['a', 'b', 'c'];
arr['0'] // 'a'
arr[0] // 'a'
但是,一定要区分数组索引和对象的属性名:所有的索引都是属性名,但只有在0~2(32次方)-2(4294967294)之间的整数属性名才是索引
var a = [];
//索引
a['1000'] = 'abc';
a[1000] // 'abc'
//索引
a[1.00] = 6;
a[1] // 6
单独的索引不能做表示符,所以数组元素只能用方括号法表示。
var arr = [1, 2, 3];
arr[0];//1
arr.0;//SyntaxError
可以使用负数和非整数来索引数组,由于其不在0~2的32次方-2的范围内,所以,只是数组的属性名。而不是数组的索引,明显的特征是不会改变数组的长度。
//属性名
a[-1.23]=true;
console.log(a.length);//3
//索引
a[10] = 5;
console.log(a.length);//11
//属性名
a['abc']='testing';
console.log(a.length);//11
*稀疏数组*
稀疏数组就是包含从0开始的不连续索引的数组。
知道稀疏数组的、最直接的方式就是使用delete操作符。
var a = [1,2,3,4,5];
delete a[1];//删除索引为一的元素。
console.log(a[1]);//undefined
console.log(1 in a);//false
数组的逗号之间可以省略元素值,通过省略元素值也可以知道稀疏数组。
var a =[1,,3,4,5];
console.log(a[1]);//undefined
console.log(1 in a);//false
如果数组的末尾使用逗号,浏览器之间有差别。标准浏览器会忽略该逗号,而IE8会在末尾田间undefined.
//标准浏览器输出[1,2],而IE8-浏览器输出[1,2,undefined]
var a = [1,2,];
console.log(a);
//标准浏览器输出2,而IE8-浏览器输出3
var a = [,,];
console.log(a.length);
足够稀疏的数组通常在实现上比稠密的数组更慢,内存利用率更高,在这样的数组中查找元素的时间与常规对象属性的查找时间一样长.
数组长度
每个数组有一个length属性,就是这个属性使其区别于常规的javascript对象。针对稠密(也就是非稀疏)数组,length属性值代表数组中元素的个数,其值比数组中最大的索引大1。
[].length //=>0:数组没有元素
['a','b','c'].length //=>3:最大的索引为2,length为3
当数组是稀疏数组时,length属性值大于元素的个数,同样地,其值比数组中最大的索引大1
[,,,].length; //3
(Array(10)).length;//10
var a = [1,2,3];
console.log(a.length);//3
delete a[1];
console.log(a.length);//3
数组的特殊性主要体现在数组长度是可以动态调整的:
- 如果为一个数组元素赋值,索引i大于等于现有数组的长度时,length属性的值将设置为i+1
var arr = ['a', 'b'];
arr.length // 2
arr[2] = 'c';
arr.length // 3
arr[9] = 'd';
arr.length // 10
arr[1000] = 'e';
arr.length // 1001
- 设置length属性为小于当前长度的非负整数n时,当前数组索引值大于等于n的元素将从中删除
a=[1,2,3,4,5]; //从5个元素的数组开始
a.length = 3; //现在a为[1,2,3]
a.length = 0; //删除所有的元素。a为[]
a.length = 5; //长度为5,但是没有元素,就像new Array(5)
将数组清空的一个有效方法,就是将length属性设为0;
- 将数组的length属性值设置为大于其当前的长度。实际上这不会向数组中添加新的元素,它只是在数组尾部创建一个空的区域.
var a = ['a'];
a.length = 3;
console.log(a[1]);//undefined
console.log(1 in a);//false
如果人为设置length为不合法的值(即0——232-2范围以外的值),javascript会报错
// 设置负值
[].length = -1// RangeError: Invalid array length
// 数组元素个数大于等于2的32次方
[].length = Math.pow(2,32)// RangeError: Invalid array length
// 设置字符串
[].length = 'abc'// RangeError: Invalid array length
由于数组本质上是对象,所以可以为数组添加属性,但是这不影响length属性的值
var a = [];
a['p'] = 'abc';
console.log(a.length);// 0
a[2.1] = 'abc';
console.log(a.length);// 0
数组遍历
使用for循环遍历数组元素是最常见的方法
var a = [1, 2, 3];
for(var i = 0; i < a.length; i++) {
console.log(a[i]);
}
也可以使用while循环
var a = [1, 2, 3];
var l = a.length;
while(l--) {
console.log(a[i]);
}
如果数组是稀疏数组,使用for循环需要添加一些额外的条件
//跳过不存在元素
var s = [1,,,6];
for(var i=0;i<s.length;i++){
if(!(i in a)){
continue
}else{
console.log(a[i])
}
}
使用for/in循环处理稀疏数组。循环每次,将一个可枚举的属性名(包括数组索引)付给循环变量。不存在的索引将不会被遍历到
var s = [1,,,2];
for(var i in s){
console.log(s[i]);
}
由于for/in循环能够枚举继承的属性名,如添加到Array.prototype中的方法。由于这个原因,在数组上不应该使用for/in循环,除非使用额外的检测方法来过滤不想要的属性.
var a = [1,,,2];
a.b = 'b';
for(var i in a){
console.log(a[i]);//1 2 'b'
}
//跳过不是非负整数的i
var a = [1,,,2];
a.b = 'b';
for(var i in a){
if(String(Math.floor(Math.abs(Number(i)))) !== i) continue;
console.log(a[i]);//1 2
}
javascript规范允许for/in循环以不同的顺序遍历对象的属性。通常数组元素的遍历实现是升序的,但不能保证一定是这样的。特别地,如果数组同时拥有对象属性和数组元素,返回的属性名很可能是按照创建的顺序而非数值的大小顺序。如果算法依赖于遍历的顺序,那么最好不要使用for/in而用常规的for循环.
类数组
拥有length属性和对应非负整数属性的对象叫做类数组(array-like object);
var s = {};
var i = 0;
while (i < 10){
s[i] = i*i;
i++;
}
s.length = i;
var total = 0;
for(var j = 0; j < a.length; j++){
total += a[j];
}
有三个常见的类数组对象:
1: arguments对象
// arguments对象
function args() { return arguments }
var arrayLike = args('a', 'b');
arrayLike[0] // 'a'
arrayLike.length // 2
arrayLike instanceof Array // false
DOM方法(如document.getElementsByTagName()方法)返回的对象
// DOM元素
var elts = document.getElementsByTagName('h3');
elts.length // 3
elts instanceof Array // false
字符串
// 字符串
'abc'[1] // 'b'
'abc'.length // 3
'abc' instanceof Array // false
字符串是不可变值,故当把它们作为数组看待时,它们是只读的。如push()、sort()、reverse()、splice()等数组方法会修改数组,它们在字符串上是无效的,且会报错
var str = 'abc';
Array.prototype.forEach.call(str, function(chr) {
console.log(chr);//a b c
});
Array.prototype.splice.call(str,1);
console.log(str);//TypeError: Cannot delete property '2' of [object String]
数组的slice方法将类数组对象变成真正的数组
var arr = Array.prototype.slice.call(arrayLike);
javascript数组方法是特意定义为通用的,因此它们不仅应用在真正的数组而且在类数组对象上都能正确工作。在ECMAScript5中,所有的数组方法都是通用的。在ECMAScript3中,除了toString()和toLocaleString()以外的所有方法也是通用的
var a = {'0':'a','1':'b','2':'c',length:3};
Array.prototype.join.call(a,'+');//'a+b+c'
Array.prototype.slice.call(a,0);//['a','b','c']
Array.prototype.map.call(a,function(x){return x.toUpperCase();});//['A','B','C']
感觉都升华了。