javascript数组

javascript数组

数组

数组是值的有序集合.每个值叫做元素.每个元素在数组中都有数字位置编号,即索引.
javascript的数组是弱类型的,数组中可以含有不同类型的元素.
数组元素甚至可以是对象或其他数组.

数组对象的原型:
[] => Array.prototype

创建数组-数组直接量

  • 数组直接量中的值不一定是常量,可以是任意的表达式
  • 可以包含对象直接量或其他数组直接量
  • 省略数组直接量中的某个值,省略的元素将被赋予undefined值
    var hotels = ['ibu','kiri','tane','yaku'];
    var contact = [
    		{tel:'099-XXXX-XXXX',email:'XXX@gmail.com'},
    		{tel:'097-XXXX-XXXX',email:'YYY@gmail.com'}
    		];
    var arr = [123,true,null,"ryu"];
    var arrInArr = [[1,2],[3,4,5]];
    var commasArr = [1,2,,4];
    

创建数组-new Array

调用构造函数来创建数组.

// 创建空数组,等同于数组直接量[]
var arr = new Array();

// 有一个参数时,指定长度.
// 大小为100的数组
var arrWithLength = new Array(100);

// 等价于[123,true,null,"ryu"]
var arrLikesLiteral = new Array(123,true,null,"ryu");

数组的基本特性

  • 数组的大小:0-2^23-1(4,294,967,295).
  • 当使用小于2^32的非负整数作为属性名时,数组会自动维护其length属性值.
数组的索引和对象的属性名的差别
  • 所有的索引都是属性名.但只有在0到2^32-2之间的整数属性名才是索引.
  • 所有的数组都是对象,可以为其创建任意名字的属性.
  • 使用了非负整数的字符串,会当作数组索引,而非对象属性.
  • 使用负数或非整数来索引数组,数值将转为字符串.

var arr = [1,2,3,4,5,6];
arr.length; // 6

arr[arr.length] = 7;
arr; // 1,2,3,4,5,6,7

// 在数组头部添加
arr.unshift(0);
arr; // 0,1,2,3,4,5,6,7

// 删除元素
delete arr[2]
arr; // 0,1,empty,3,4,5,6,7
2 in arr;// false

// 删除最后元素
arr.length -= 1;
arr; // 0,1,empty,3,4,5,6

// 删除最后元素
arr.pop();
arr; // 0,1,empty,3,4,5

// 删除第一个元素
arr.shift();
arr; // 1,empty,3,4,5

数组的迭代

var arr = [1,2,3,4,5];
for(i=0;i<arr.length;i++){
	console.log(arr[i]);
}
for(i in arr){
	if(arr.hasOwnProperty(i)){
		console.log(arr[i]);
	}
}
for(i=0;i<arr1.length;i++){
	// 排除null,undefined和不存在元素
	if(!a[i]) continue;
	// 只跳过undefined和不存在元素
	if(a[i] ==== undefined) continue;
	// 只跳过不存在的元素
	if (!(i in a)) continue;
}

二维数组

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

稀疏数组

并不含有从0开始的连续索引的数组,叫稀疏数组.一般length属性值比实际元素个数大.

  • 足够稀的数组通常在实现上比稠密的数组更慢,内存利用率更高.
  • 当省略数组直接量中的值时,这时得到的数组也是稀疏数组,省略掉的值是不存在的.

var arr = new Array();
arr.length = 100;aaa
arr[99] = 124;
99 in arr; // true
98 in arr; // flse

数组方法

  • Array.prototype.join

    将数组转换为字符串.

    var arr = [1,2,3];
    // 省略参数时,自动添加[,]
    arr.join(); // 1,2,3
    arr.join(?); // 1?2?3
    //
    function repeatString(str,n){
    	return new Array(n+1).join(str);
    }
    repeatString("hello",3); // "hellohellohello"
    

  • Array.prototype.reverse

    将数组逆序.

    var arr = [1,2,3];
    arr.reverse(); // [3,2,1]
    // 原数组被修改
    arr; // [3,2,1]
    

  • Array.prototype.sort

    排序.

  • 数组包含undefined时,它们会被排到数组的尾部.

    var arr = ['a','c','d','b'];
    // 原数组被修改
    arr.sort(); // ['a','b','c','d']
    
    // number
    var arr = [13,23,56,3];
    arr.sort(); // [13,23,3,56]
    arr.sort(function(a,b){
    	return a-b;
    }); // [3,13,23,56]
    
    arr = [
    		{age:25},
    		{age:34},
    		{age:12}
    	];
    arr.sort(function(a,b){
    	return a.age-b.age;
    });
    arr.forEach(function(item){
    	console.log("age",item.age);
    });
    

  • Array.prototype.concat

    合并数组.

    var arr = [1,2,3];
    arr.concat(4,5); // [1,2,3,4,5]
    // 原数组不被修改
    arr; // [1,2,3]
    
    // 数组被平铺
    arr.concat([10,11],13); // [1,2,3,10,11,13]
    
    // 数组中的数组不会被平铺两次
    arr.concat([1,[2,3]]); // [1,2,3,1,[2,3]]
    

  • Array.prototype.slice

    返回部分数组

    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; // [1,2,3,4,5]
    

  • Array.prototype.splice

    数组拼接

  • 能够从数组中删除元素,插入元素到数组中或者同时完成这两种操作.

  • 在插入或删除点之后的数组元素会根据需要增加或减少它们的索引值.

    var arr = [1,2,3,4,5];
    // 第一个参数为索引.第二个参数为想要删除的个数.
    arr.splice(2); // return[3,4,5]
    // 原数组不被修改
    arr; // [1,2]
    
    var arr = [1,2,3,4,5];
    arr.splice(2,2); // return [3,4]
    arr; // [1,2,5]
    
    var arr = [1,2,3,4,5];
    arr.splice(1,1,"a","b"); // return [2]
    arr; // [1,"a","b",3,4,5]
    
    

数组方法

  • 大多数的数组方法的第一个参数接受一个函数,并且对数组的每个元素调用一次该函数.

  • 大多数情况下,函数使用三个参数:

    • 数组元素
    • 元素的索引
    • 数组本身
  • Array.prototype.forEach

    从头到尾遍历数组,为每个元素调用指定的函数.

  • 无法在遍历完成前终止遍历.即不能使用break;

    var arr = [1,2,3,4,5];
    arr.forEach(function(x,index,a){
    	console.log(x + '<->' + index + '<->' + (a===arr));
    });
    // 1 <-> 0 <-> true ---> 5 <-> 4 <-> true
    

  • Array.prototype.map

    数组映射.
    将调用的数组的每个元素传递给指定的函数,并返回一个数组.它包含该函数的返回值.

    var arr = [1,2,3,4,5];
    arr.map(function(x){
    	return x + 10;
    }); // [11,12,13,14,15]
    // 原数组不被修改
    arr;// [1,2,3,4,5]
    

  • Array.prototype.filter

    过滤数组.
    返回的数组元素是调用的数组的一个子集.

  • filter会跳过稀疏数组中缺少的元素.

    var arr = [1,2,3,4,5,6,7,8,9,10];
    arr.filter(function(x,index){
    	return index % 3 === 0 || x >= 8;
    }); // return [1,4,7,8,9,10]
    // 原数组不被修改
    arr;// [1,2,3,4,5,6,7,8,9,10]
    a = a.filter(function(x){
    	return x !== undefined && x != null;
    })
    

  • Array.prototype.every & some

    数组判断
    是数组的逻辑判定:对数组元素应用指定的函数进行判定,返回true或false.

    var arr = [1,2,3,4,5];
    // every 数组中的每个元素都要符合[function]条件
    arr.every(function(x){
    	return x < 10;
    }); // true
    
    arr.every(function(x){
    	return x < 3;
    }); // false
    
    // some 数组中的某个元素只要符合[function]条件
    arr.some(function(x){
    	return x === 10;
    }); // true
    
    arr.some(function(x){
    	return x === 100;
    }); // false
    
    

  • Array.prototype.reduce & reduceRight

    把数组中的元素两两操作得到什么结果.

var arr = [1,2,3];
// 这里的[0]是第二个参数.可有可无.即数组中的第一个元素先于第二个参数相加,然后在做x+y操作.没有时,则直接xy相加.
var sum = arr.reduce(function(x,y){
	return x + y;
},0); // 6
arr; // [1,2,3]

var arr = [3,6,9];
var max = arr.reduce(function(x,y){
	console.log(x + '|' + y);
	return x > y ? x : y;
});
// 3|9
// 6|9
max; // 9

// reduceRight与reduce相仿.表示从右开始元素的操作.
var arr = [3,6,9];
var max = arr.reduceRight(function(x,y){
	console.log(x + '|' + y);
	return x > y ? x : y;
});
// 9|6
// 9|3

  • Array.prototype.indexOf & lastIndexOf

    数组检索

    var arr=[1,2,3,2,1]
    // 第一个参数是想查找的元素,第二个参数表示从第几个元素开始查找.返回下标.
    arr.indexOf(2);
    // 1
    arr.indexOf(99)
    // -1 没有时返回-1
    arr.indexOf(1,1)
    // 4
    arr.indexOf(1,-3)
    // 4
    arr.indexOf(2,-1)
    // -1
    // 数组从右开始查找.
    arr.lastIndexOf(2)
    // 3
    

  • Array.isArray()

    判断是否是数组

    var arr = [1];
    Array.isArray(arr); // true
    
    // 还可以通过以下方法来判断
    arr instanceof Array; // true
    ({}).toString.apply(arr); // "[object Array]"
    arr.constructor === Array; //true
    

数组和一般对象的区别

  • 相同点

    • 都可以继承.
    • 数组是对象,对象不一定是数组
    • 都可以当做对象添加删除属性
  • 不同点

    • 数组自动更新length
    • 按索引访问数组常常比访问一般对象属性迅速
    • 数组对象继承Array.prototype上的大量数组操作方法

作为数组的字符串

字符串的行为类似于只读数组.

var str = "hello world";
str.charAt(0); // h
str[1]; // e

Array.prototype.join.call(str,"_"); //"h_e_l_l_o_ _w_o_r_l_d"

发表评论

邮箱地址不会被公开。 必填项已用*标注