JavaScript学习笔记-数组

数组

数组中的每个元素的位置是索引，索引是基于32位的由0开始的数值，最大索引为（2的32次方-2），最大长度为（2的32次方-3）

数组是无类型的：元素可为任意类型；动态的：可根据需要自动增长、缩减，也可在声明时固定大小；可能是稀疏的：索引不一定是连续的，可有空缺，length为元素个数

var a = [1,2, , 3, undefined,{a:1,b:2},]; //使用Object的构造函数

var x = new Array(10) //固定长度，使用Array的构造函数

数组元素的访问a[i]，和用p[‘x’]访问对象的属性一样，先把数字索引转为字符串，然后将它作为属性名来使用，数组其实是对象的特殊形式；

数组是对象，可以为它创建任意名字的属性，而只有在0 ~（2的32次方-2）之间的整数属性名才是索引，而任何其它名字都只能当做是普通属性名，小数部分为0的浮点数也是索引；

a[-5] = ‘str’; //为数组创建一个名为’-5‘的属性，值为’str’;

a[13.000] = 4; //把索引为13的元素的值设为4；

用索引访问数组比用属性访问数组要高效；

var a = [1,2,3,4,5];

a.length = 3; //a=[1,2,3]，后面的呗删除；

a.length = 0; //a=[]，删除索引元素；

a.length = 5; //a的长度为5，但没有元素，等同于new Array(5);

数组的方法

push(x1,x2…) 在原数组尾部增加1个或多个元素x，返回改变后的数组长度，pop()删除最后一个元素，返回被删的元素；；

unshift(x1,x2…) 在头部一次性插入1个或多个元素，返回数组长度，后面的索引随之改变，shift() 删除第一个元素，并返回被删除的元素；

join(str) split(str) 返回一个将所有元素转化为字符串并用符号str连接而成的字符串，而split(str)则相反，按str分割为元素组成数组并返回；

a.reverse() 颠倒数组a中的元素的顺序，返回被重排后的原数组a；

a.sort(f) 无参数时按字母顺序表排序，返回被重排后的原数组a，函数f用来指定排序规则；

a.concat(6,7,[8,9],[10,[11,12]]) 返回一个新数组（含数组a的元素和所有参数作为元素，若参数为数组，则拆散为元素，但不拆也是数组的元素，[1,2,3,4,5,6,7,8,9,10,[11,12] ]）;

a.slice(a,b) 返回数组的一个子数组，含从索引a到索引b(不含b)之间的元素，只有一个参数则表示从a直到到尾部，负数表示从-1开始倒着数；

a.splice(a,n,x1,x2,x3…) 改变了数组a，返回被删除的元素组成的数组（从索引a处开始删除n个元素，可选的后续参数是要在索引a处插入的元素）；

toString() toLocalString() 对数组的所有元素执行该方法，最后返回用逗号分隔的所有元素的字符串形式的字符串列表，不含’[ ]’和其它分隔符，

b=a.map(function(x,i,a1){return x*x}); 遍历数组a的每个元素值来执行函数代码，然后返回一个由函数的返回值组成的新数组，该函数必须有返回值，后面2个可选参数；

b=a.filter(function(x,i,a1){return …}); 遍历数组a的元素值，根据函数的返回值是否为true来决定是否将x取出来放入最后要返回的数组，filter()会跳过空缺的元素，如：a=a.filter(function(x){return true;});或x!==undefined&&x!=null过滤掉数组中的undefined、null元素；

a.every(function(x){return x<10;}) （用来判断数组中所有元素是否都符合需求）仅当对数组中的所有元素值x执行函数判断都返回true时，最后才返回true，遍历到第一个返回false是就终止遍历，直接返回false；

a.some(function(x){return x%2==0;})，a.some(isNaN) （用来判断数组中是否有元素不符合需求）当遍历到数组中有一个元素调用判定函数返回true时，就返回true；

max=a.reduce(function(x,y){return (x>y)?x:y;}, 0) 将数组a中的所有元素按函数规则化简为‘一’，并返回这个‘一’，第二个参数是给函数的x赋初始值，reduceRight()是从右侧元素开始化简；

a.indexOf(x,i) 从头至尾搜索并返回数组或字符串a中第一个元素x的索引，若没找到则返回-1，lastIndexOf()反向搜索，可选参数i为指定从索引i处开始搜索；

Array.isArray(a) 判断对象a是否为数组，返回true/false；

delete a[n]； 删除指定元素，留下一个值为undefined的空位，数组变为稀疏数组；

遍历数组：

for(var i=0,len=a.length;i<len;i++){…} //普通数组遍历，通过索引i遍历；

for(var n in a){…} //一般用来遍历带有key的对象，遍历可枚举属性，n为属性名；

a.forEach(function(x,i,a1){…}); //forEach中的x为属性的值，i为索引，a1为数组自身，参数个数可选，forEach无法中断，直到遍历完所有元素，可通过用try来包含forEach，抛出异常而达到中断遍历；

类似为数组的对象：(字符串也是类数组，且为只读不能调用修改数组的方法)

如果对象p的所有元素的key符合数组索引的特征，可以为该对象添加length属性，这样就有了数组的特征，可以间接的调用数组的所有方法：因为他不是继承自Array.prototype，所以要间接使用Function.call方法来调用，（除concat()方法效果不同），如：Array.prototype.join.call(p,’+’)，Array.prototype.slice.call(p,3);

var a1 = [1,2,3,4,5,6,7];

try {

a1.forEach(function(x,i,a){

if(x<=5){

a[i] = x+1;

}

else{

throw 'big';

}

});

}

catch(e){

console.log(e); //big

}

console.log(a1); //[ 2, 3, 4, 5, 6, 6, 7 ]

//===================

b=a1.map(function(x,i,a){

a[i]+=2;

return x+=1;

});

console.log(b); //[ 2, 3, 4, 5, 6, 7, 8 ]

console.log(a1); //[ 3, 4, 5, 6, 7, 8, 9 ]

//====================

var a1 = [{x:1,a:1},{y:2,a:2},{z:3,a:3}];

var union = function(x,y){

var a2={};

for(var q in x){

a2[q]=x[q];

}

for(var z in y) {

if (z in x) continue;

a2[z]=y[z];

}

return a2;

};

var b = a1.reduce(union);

var b1 = a1.reduceRight(union);

console.log(b); //{ x: 1, a: 1, y: 2, z: 3 }

console.log(b1); //{ z: 3, a: 3, y: 2, x: 1 }

//=====================

var p = {'0':'x','1':'s','2':'g'};

p.length=3;

var s=Array.prototype.concat.call(p,3,4,5);

console.log(s); //[ { '0': 'x', '1': 's', '2': 'g', length: 3 }, 3, 4, 5 ]

console.log(Array.isArray(p)); //false