数组概述
数组对象继承Array.prototype上的大量数组操作方法
JavaScript中的数组是弱类型的,数组中可以含有不同类型的元素,数组元素甚至可以是对象或其他数组。
var arr = [1,null,undefined,"hello",{x:1,y:2},[1,2,3]]; //弱类型,元素类型可以不同
JS允许数组中最后有一个多余的逗号(,)
var arr2 = [,,]; [undefined,undefined]
arr2.length; //2 两个undefined元素
size from 0 to 2^23-1(4294967295)
var arr = new Array; // var arr = [];
var arrWithLength = new Array(100); // var arr = [,,..,] //99/100个逗号
var arrLikesLiteral = new Array(true,false,null,1,2); // var arr = [true,false,null,1,2];
数组可以动态的增加元素,即使超出了定义的长度范围
var arr = [1,2,3,4,5];
arr[5] = 6; //动态增加一个元素
arr.length; // 6
数组的删除delete,不会缩短数组长度,只会将该值变为undefined
var arr = [0,1,2,3,4,5]
delete arr[0];
arr[0]; //undefined
0 in arr; //false //0不存在
arr.length; //6 不会缩短
arr[1] = undefined; //直接赋值为undefined
1 in arr; //true 仍然存在
==================以下三种删除元素都会改变数组的长度==================
arr.length -= 1; //缩短arr的长度,自动会删除最后一个元素(尾部)
arr.length; //会减小1
arr.pop(); //弹出下标最大(尾部)的数字
arr.length; //会减小1
arr.shift(); //弹出最小下标(头部)的数字
arr.length; //会减小1
数组的增删——动态的、无需指定大小
var arr3 = [];
arr3[0] = 1;
arr3[1] = 2;
arr3.push(3); //在尾部添加元素
arr3[arr3.length] = arr3.length+1;
document.write(arr3);
arr3.unshift(0); //在头部添加元素
数组的迭代遍历
var arr4 = [1,2,3,4];
for(var i=0;i<arr4.length;i++){
console.log(arr4[i]);
}
坑!!!!!
1.in是没有顺序的
2.in会遍历arr4数组的值和arr4的属性,还有arr4原型链上的所有可enumerable的属性
for(i in arr4){
console.log(arr4[i]);
}
二维数组
定义
var arr = [[0,1],[2,3],[4,5]];
其余均与Java数组操作类似,不赘述
稀疏数组
稀疏数组并
不含有从0开始的
连续索引。一般
length属性值比实际元素个数大。
var arr = new Array(10);
0 in arr; //false
数组方法
原型链
{} ==> Object.prototype
[] ==> Array.prototype
将数组转换为字符串 join
var arr = [1,2,3];
arr.join(); // "1,2,3"
arr.join("_"); //"1_2_3"
数组逆序 reverse
var arr = [1,2,3];
arr.reverse(); //[3,2,1]
arr; [3,2,1] //会直接改变原数组
排序 sort
排序方法会在原数组本身操作,改变原数组
var arr = ['a','d','b','c'];
arr.sort(); //['a','b','c','d']
sort方法会将元素转换成字符串,然后按照字母顺序进行排序
var arr1 = [13,24,51,3];
arr1.sort(); //[13,23,3,51]
并没有按照数字的大小排列
arr1.sort(function(a,b){
return a-b;
}); //[3,13,23,51]
数组合并 concat
concat 不会修改原数组
var arr = [1,2,3];
arr.concat(4,5); //[1,2,3,4,5]
arr.concat([6,7],8); //[1,2,3,4,5,6,7,8]
arr.concat([9,[10,11]]); //[1,2,3,4,5,6,8,9,[10,11]]
返回部分数组 slice
slice(n,m); 表示[n,m) 左闭右开
var arr = [1,2,3,4,5];
arr.slice(1,3); //[2,3]
arr.slice(1); //[2,3,4,5]
arr.slice(1,-1); //[2,3,4]
arr.slice(-4,-3); //[2]
数组拼接 splice
splice 对原数组进行修改
splice(start); //start表示删除的起点,直接删除到末尾
var arr = [1,2,3,4,5];
arr.splice(2); //return [3,4,5]
arr; //[1,2] 原数组被修改
splice(start,count) //start表示删除的起点,count表示删除的个数
arr = [1,2,3,4,5]
arr.splice(2,2) //return [3,4]
arr; //[1,2,5]
splice(start,count,param1,param2,..) //param1,param2表示在删除的下标出添加的元素
arr = [1,2,3,4,5]
arr.splice(1,1,'a','b'); //return [2]
arr; //[1,'a','b',3,4,5];
数组遍历 forEach
var arr = [1,2,3,4,5];
arr.forEach(function(x,index,a){
console.log("arr[" + index + "] = " + x); arr[0] = 1;.....
});
数组映射 map
var arr = [1,2,3];
arr.map(function(x){
return x + 10; //映射函数
}); //[11,12,13]
arr; //[1,2,3]
不会修改原数组
数组过滤 filter
var arr = [0,1,2,3,4,5,6,7,8,9,10];
arr.filter(function(x,index){
return index%3===0;
}); //[0,3,6,9]
arr; //[0,1,2,3,4,5,6,7,8,9,10]
不会修改原数组
每一个元素均符合条件才返回true every
var arr = [1,2,3,4,5,6,7,8,9];
arr.every(function(x){
return x<10;
//每一个元素都满足条件时,every返回true
}); //true
arr.every(function(x){
return x<3;
}); //false
只要有一个元素满足条件时返回true some
var arr = [1,2,3,4,5];
arr.some(function(x){
return x < 3;
//只要有一个满足则返回true
}); //true
arr.some(function(x){
return x <0;
}); //false
两两操作数组元素,返回一值 reduce | reduceRight
reduce(function,val); //function为两两比较的返回算法函数,val表示x作为初始参数,可不传
reduceRight //reduceRight的功能和reduce功能相同,但是是从数组右边(尾部)开始
var arr3 = [1,2,3,4,5];
var sum = arr3.reduce(function (x,y){
return x + y; //两两对比,取和为返回值
});
sum; //数组求和 15
var max = arr3.reduceRight(function (x,y){
return x > y ? x : y; //两两对比,取较大值为返回值
});
max; //求最大值 5
数组检索 indexOf
indexOf(val); //检索val是否在数组中,若存在返回下标index,若不存在,返回-1 从左向右
indexOf(val,start); //从start处向右检索val,若存在,则返回第一个index,若不存在,返回-1
indexOf(val,start); //可能出现数组中存在val,但由于start限制起点导致未检索到
lastIndexOf(val);
lastIndexOf(val,start); //与indexOf功能类似,但是从右向左查找
判断是否为数组 isArray
Array.isArray([]); //true
[] instanceof Array; //true
({}).toString.apply([]) === '[object Array]'; //true
[].constructor === Array; //true