JavaScript学习笔记——数组

数组概述

---

数组对象继承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