js数组

<script>
var arr=[1,2,'a'];
arr.length=5;
p(arr[3]); //undefined
arr.length=1;
p(arr[1]); //undefined
</script>

数组的枚举
数组长度上限2的32次方

<script>
var arr=['f',1,2,'a','b','c'];
for(var k in arr){
    p(arr[k]);
}
//for in有时无法保证枚举顺序
for(var i=0;i<arr.length;i++){
    p(arr[i]);
}
/*
f
1
2
a
b
c
*/
//v 数组的值,key下标,ar数组对象
arr.forEach(function(v,key,ar){
    ar[key]=v+"_";
})
p(arr);//f_,1_,2_,a_,b_,c_
p(Object.keys(arr));  //0,1,2,3,4,5
p(Object.getOwnPropertyNames(arr));//0,1,2,3,4,5,length
p(arr.__proto__==Array.prototype); //true
p(Object.getOwnPropertyNames(Array));// length,name,arguments,caller,prototype,isArray,observe,unobserve
</script>

Array类的属性

p( Array.isArray(arr)) //true or false

<script>
var arr=['f',1,2,'a','b','c'];
p( arr.constructor);//function Array() { [native code] }
p(Array.constructor);//function Function() { [native code] }
p(Array.prototype.constructor);//function Array() { [native code] }
p(arr.constructor==Array.prototype.constructor);//true

var arr=['f',1,2,'a','b','c'];
var a='w';
var arr1=['q','w1'];
var b=arr.concat(a,arr1);
p(b);//f,1,2,a,b,c,w,q,w1
var c='a'.concat('b');
p(c);//ab
</script>

Array.prototype对象的属性

every

<script>
var arr=['f1',1,2,'a','b','c'];
function callback(element,index,arrobj){
    return arrobj[index]=element+'_';
    //此函数必须return true默认return false,到return false就停止执行
}
arr.every(callback);  //true
p(arr);//f1_,1_,2_,a_,b_,c_
</script>

 filter

<script>
var arr=['f1',1,2,'a','b','c'];
function callback(element,index,arrobj){
    if(!isNaN(element)) return true;
}
var arr1=arr.filter(callback);  //true
p(arr1);//1,2
</script>

 indexOf()

<script>
var arr=['f1',1,2,'a','b','c','a'];
var r=arr.indexOf('a',3); //3  第二个参数不传的话默认从开始查找
var r1=arr.indexOf('a',4);//6
p(r,r1);//3,6
p('abc'.indexOf('c'));//2
</script>

 join

<script>
var arr=['f1',1,2,'a','b','c','a'];
var str=arr.join('-');
p(str);//f1-1-2-a-b-c-a
</script>

 lastIndexOf()

<script>
var arr=['f1',1,2,'a','b','c','a','d'];
var r=arr.lastIndexOf('a',7);
var r2=arr.lastIndexOf('a',3);
p(r,r2);//6,3  找不到就返回-1
</script>

map()

<script>
var arr=['f1',1,2,'a','b','c','a','d'];
function callback(element,index,obj){
    obj[index]=element+"__";
    return element+"_";
}
var arr1=arr.map(callback);
p(arr1);//f1_,1_,2_,a_,b_,c_,a_,d_
p(arr);//f1__,1__,2__,a__,b__,c__,a__,d__
</script>

pop()

<script>
var arr=['f1',1,2,'a','b','c','a','d'];
var arr1=arr.pop();//d
p(arr,arr1);//f1,1,2,a,b,c,a       d
</script>

 reduce(callbackfn[,initialValue);

callbackfn函数对数组计算,返回最后一次计算结果
callbackfn(x,y)
如果在调用reduce时有初始值,那么x就做为初始值
y依次为数组元素
如果没有初始值
数组第一个元素作为初始值,y为从第二个元素开始的数组元素

<script>
var arr1=[5,2,3,4,'a'];
function callback(x,element){
    p(x+":"+element);
    return x+"_"+element;
}
var r=arr1.reduce(callback);
p("<hr>");
p(r);
/*
没初始值得结果
5:2
5_2:3
5_2_3:4
5_2_3_4:a
------------------------
5_2_3_4_a
有初始值得结果   r=arr1.reduce(callback,'init');
init:5
init_5:2
init_5_2:3
init_5_2_3:4
init_5_2_3_4:a
-----------------------------------
init_5_2_3_4_a
*/
</script>

reduceRight(callbackfn,[,initval])
从数组的末尾向前执行reduce操作
reverse数组转置

<script>
var arr=['f1',1,2,'a','b','c','a','d'];
arr.reverse();
p(arr);//d,a,c,b,a,2,1,f1
</script>

 shift删除数组的第一个元素,并返回该元素

<script>
var arr=['f1',1,2,'a','b','c','a','d'];
p(arr.shift());
p(arr);
</script>

 unshift(item0,item1)

添加元素导数组开头,返回添加后数组的长度

<script>
var arr=['f1',1,2,'a','b','c','a','d'];
p(arr.unshift('first','second'));//10
p(arr);//first,second,f1,1,2,a,b,c,a,d
</script>

slice(start,end)生成一个下标从start到end的新数组

<script>
var arr=['f1',1,2,'a','b','c','a','d'];
p(arr.slice(1,4));//1,2,a
p(arr);//f1,1,2,a,b,c,a,d
</script>

splice(start,delcount,[item0,item1,...])
删除下标由start开始的delcount个元素,如果指定第三个参数,则将该参数插入到start的位置
返回删除的元素

<script>
var arr=['f1',1,2,'a','b','c','a','d'];
p(arr.splice(1,2));//1,2
p(arr);//f1,a,b,c,a,d

var arr=['f1',1,2,'a','b','c','a','d'];
p(arr.splice(1,2,'new','nn'));//1,2
p(arr);//f1,new,nn,a,b,c,a,d
</script>

some(callbackfn[,thisarg]) 以此对数组中的元素应用callbackfn,如果callbackfn返回true则终止
callbackfn(数组元素,下标,数组对象)

<script>
var arr=['f1',1,2,'a','b','c','a','d'];
function callbackfn(element,index,arrobj){
    p(element+":"+index+":"+typeof arrobj);
}
arr.some(callbackfn);
</script>

toLocaleString();//将数组转换为与地区相关的字符串类型
toString转换为字符串

<script>
ar arr=['f1',1,2,'a','b','c','a','d'];
var r=arr.toLocaleString();
var r1=arr.toString();
p(r,r1);
p(typeof r,typeof r1);
</script>

 toSource();

sort排序自定义排序规则 

<script>
var arr1=[1,30,2,4];
var arr2=arr1.sort(function(a,b){
    return a-b;
});
p(arr1,arr2);//均是1,2,4,30
//默认按照 1,2,30,4
//如果不调用 sort了的参数,排序是通过对unicode编码值得大小比较来实现的
</script>

js数组含有很多破坏性方法(使用该方法后原数组也被改变)
pop,push,reverse,shift,sort,splice,unshift
可使用freeze方法使其免遭破坏
Object.freeze(arr);
之后再调用破坏性方法 就会报错了

 

数组的复制
由于js里的数组是对象
数组赋值时带入的只是其引用,因为实际上并没有复制数组元素,仅仅是将某一个变量指向了同一个数组实体而已 

<script>
var arr1=[1,30,2,4];
var arr2=arr1;
arr2.push(5);
p(arr2,arr1);  //arr2改变时,arr1也改变,两者指向同一个实体
</script>

通过contact,slice对数组赋值

<script>
var arr1=[1,30,2,4];
var arr2=[].concat(arr1);
arr2.push(5);
p(arr2,arr1);
//1,30,2,4,5
//1,30,2,4
//通过slice对数组进行赋值

var arr1=[1,30,2,4];
var arr2=arr1.slice(0,arr1.length);
arr2.push(5);
p(arr2,arr1);
//1,30,2,4,5
//1,30,2,4
</script>

元素的删除

方式1
<script>
var arr1=[1,30,2,4];
delete(arr1[1]);
p(arr1);//1,,2,4
p(arr1[1]);//undefined
p(arr1.length);//4  长度还没改变
//方法2
var arr1=[1,30,2,4];
arr1.splice(2,1);
p(arr1,arr1.length);
//1,30,4
//3
</script>

过滤

<script>
var arr=['zero','one','two','three','four'];
var p1=arr.map(function(e){
    return e.length
}).filter(function(e){
    return e%2==0;
});
p(p1);//[4,4]  数组
</script>