ECMAScript的数组,每一项可以保存任何类型的数据,数组的大小可以动态调整。
创建方法
构造函数
1. var 变量名 = new Array(数组长度(可为空)); 2. var 变量名 = new Array(项0,项1………...);
数组字面量
var 变量名= [项0,项1………(可为空)];
检测数组
1. 变量名 instanceof Array; (instanceof假定只有一个全局执行环境,当网页 包含多个框架时不适用)
2. Array.isArray(变量名);
(不管arr是在哪个全局执行环境中创建的)
转换方法
1. arr.toString() //返回字符串,以逗号分割每一项
2. arr.toLocaleString() //返回字符串,以逗号分割每一项
3. arr.valueof() //返回数组,以逗号分割每一项
4. arr.join(“分隔符”) 返回字符串,以自定义的分隔符分割每一项,若不传入分隔符,默认为逗号
若数组某项为null 或 undefined,在以上方法中, 该项显示为空字符串
栈方法 LIFO
1. 正方向模拟栈:
▪ 在数组末尾添加新项: arr.push(新项j,新项k…….); // 返回数组新的长度
▪ 在数组末尾移除项: arr.pop(); //返回移除的项
2. 反方向模拟栈:
▪ 在数组头部添加新项: arr.unshift(新项j,新项k…….); // 返回数组新的长度
▪ 在数组头部移除项: arr.shift(); //返回移除的项
队列方法 FIFO
1. 正方向模仿队列:
▪ 在数组末尾添加新项: arr.push(新项j,新项k…….); // 返回数组新的长度
▪ 在数组头部移除项: arr.shift(); //返回移除的项
2. 反方向模拟队列:
▪ 在数组头部添加新项: arr.unshift(新项j,新项k…….); // 返回数组新的长度
▪ 在数组末尾移除项: arr.pop(); //返回移除的项
重排序方法
1. arr.reverse() //反转数组项的顺序
2. arr.sort() //默认升序排列数组项,但是比较的是字符串,所以会出现 (1,10,2)的结果。
因此,最好用sort(function),接受一个比较函数
//数值类型or 其valueOf方法返回数值类型的对象类型
function compare(value1,value2){
return value1-value2; //升序
或者
return value2-value1; //降序
}
var arrays = ["80", "9", "700", 40, 1, 5, 200];
arrays.sort(compare);
console.log(arrays); //[ 1, 5, '9', 40, '80', 200, '700' ]升序
//[ '700', 200, '80', 40, '9', 5, 1 ]降序
//自实现sort方法原理
var ascsort = function(value1,value2){
return value1 - value2;
}
function descsort(value1,value2){
return value2-value1;
}
Array.prototype.mysort = function(fn){
fn = fn || function(x,y){return x-y;}; //默认升序
for(var i =0;i<this.length;i++){
for(var j=i;j<this.length;j++){
if(fn(arr[i],arr[j])>0){
arr[i] ^= arr[j];
arr[j] ^= arr[i];
arr[i] ^= arr[j];
}
}
}
}
var arr=new Array(1,10,9,22,100,31);
arr.mysort();
console.log(arr);//[ 1, 9, 10, 22, 31, 100 ]
arr.mysort(ascsort);
console.log(arr);//[ 1, 9, 10, 22, 31, 100 ]
arr.mysort(descsort);
console.log(arr);//[ 100, 31, 22, 10, 9, 1 ]
//根据对象的属性来排序
function createComparisonFunction(propertyName){
return function(object1,object2){
var value1 = object1[propertyName];
var value2 = object2[propertyName];
//忽略大小写
if(propertyName == "name"){
value1 = value1.toLowerCase();
value2 = value2.toLowerCase();
}
return +(value1 > value2)||-(value1 < value2);
};
}
var data = [{name:"Zachary",age:28},{name:"cicholas",age:30},{name:"karine",age:40},{name:"Aicholas",age:25},{name:"karine",age:40}];
data.sort(createComparisonFunction("name"));
console.log(data);
//[ { name: 'Aicholas', age: 25 },
// { name: 'cicholas', age: 30 },
// { name: 'karine', age: 40 },
// { name: 'karine', age: 40 },
// { name: 'Zachary', age: 28 } ]
data.sort(createComparisonFunction("age"));
console.log(data);
//[ { name: 'Aicholas', age: 25 },
// { name: 'Zachary', age: 28 },
// { name: 'cicholas', age: 30 },
// { name: 'karine', age: 40 },
// { name: 'karine', age: 40 } ]
分析一下return语句“return +(value1 > value2)||-(value1 < value2);”:
▪ value1>value2 -> +true||-false -> 1||-0 -> 1
▪ value1<value2 -> +false||-true -> 0|| -1 -> -1
▪ value1=value2 -> +false||-false -> 0||-0 -> -0
操作方法
1. arr.concat(参数(可以是新项or数组)) 复制数组arr,在副本数组末尾添加参数,不改变原数组。
*与arr.push(参数)的区别:
▪ push方法直接改变原数组,push方法如果接受的参数为数组,会把该参数视为一个项。
▪ concat方法不改变原数组,concat方法如果接受的参数为数组,会把该参数的每个项视为单独的项。
2. arr.slice(起始位置,结束位置(可不写)) //返回(arr[起始位置]到arr[结束位置-1])的数组,不改变原数组
3. arr.splice(起始位置,要删除的项数,插入/替换的项(可不写)) //返回包含删除项的数组,改变原数组
▪ 删除 arr.splice(2,5); // 返回空数组,原arr变成从arr[2]到arr[4]
▪ 插入 arr.splice(1,0,"red","green"); //返回空数组,red、green从原arr的arr[1]插入
▪ 替换 arr.splice(1,3,"red","green"); //返回包含arr[1],arr[2],arr[3]的数组,
red、green从原arr的arr[1]插入
arr[1],arr[2],arr[3]的数组,red、green从原arr的arr[1]插入
var arr1=new Array(0,1,2);
var arr2=[4,5,6];
var arr3=arr2.concat(arr1);
console.log(arr3); //[ 4, 5, 6, 0, 1, 2 ]
arr3[1]=6;
arr3[3]=1;
console.log(arr3); //[ 4, 6, 6, 1, 1, 2 ]
console.log(arr1); //[ 0, 1, 2 ]不会改变原数组
console.log(arr2); //[ 4, 5, 6 ]不会改变原数组
---------------------------------------------------
var arr5={name:"lala"};
var arr6=[4,5,6];
var arr7=arr6.concat(arr5);//拷贝的是对象引用
console.log(arr7); //[ 4, 5, 6, { name: 'lala' } ]
arr7[3]["name"]="xixi";
console.log(arr7); //[ 4, 5, 6, { name: 'xixi' } ]
console.log(arr6); //[ 4, 5, 6] 不会改变原数组
console.log(arr5["name"]); //xixi,作为参数的arr5原数组被改变
位置方法
1. arr.indexOf(起始位置(可不写),待查找元素) //在数组头部往后查找,返回元素在数组的位置,找不到返回-1
2. arr.lastIndexOf(结束位置(可不写),待查找元素) //在数组末尾往前查找,返回元素在数组的位置,找不到返回-1
迭代方法(不改变原数组)
作为参数的函数会接收3个参数:item,index,array
1. arr.every(函数) //如果函数对数组每一项都返回true,则返回true
2. arr.some(函数) //如果函数对数组某一项返回true,则返回true
3. arr.filter(函数) //返回一个由函数返回true的项组成的数组
4. arr.map(函数) //返回每一项调用函数的结果组成的数组
5. arr.forEach(函数) //没有返回值,每一项执行函数。
归并方法
作为参数的函数会接收4个参数:prev, cur, index, array
1. arr.reduce(函数) 从数组第一项开始,遍历到最后
2. arr.reduceRight(函数) 从数组最后一项开始,遍历到第一项。