javascript中的数组

• javascript是一门弱类型语言，javascript中的数组跟强类型的语言，如java中的数组有很大的不同。javascript中的数组是无类型的；数组元素可以是任意类型的。
• javascript数组是动态的，根据需要它们会增长或缩减，并且在创建数组是无须声明一个固定大小或者在数组大小变化时无须重新分配空间。
• javascript数组可能是稀疏的；数组元素的索引不一定是连续的，它们之间可能有空缺。每个数组都有一个length属性。针对非稀疏组，该属性就是数组元素的个数。针对稀疏数组，length比所有元素的索引要大。

/*创建数组：*/

//1.使用数组直接量，
var empty=[];//没有元素的数组
var primes=[2,3,1,"w"];//有四个元素的数组

//2.使用Array（）构造函数
var a=new Array();//没有元素的数组
var b=new Array(10);//调用时有一个数组参数，它指定长度
var c=new Array（1，2，3，4，"a"）;//有五个元素的数组

/*数组元素的添加*/
var a=[];

//为新索引赋值
a[0]="zero";
a[1]="one";

//使用push()方法在数组末尾增加一个或多个元素
a.push("two");//向数组末尾添加一个元素
a.push("three","four");//向数组末尾添加两个元素

//使用unshift()方法在数组开头添加一个或多个元素
a.unshift("yang");
a.unshift("li","jia");

/*数组元素的删除*/
 var b=[1，2，3];

//使用delete来删除元素，但是不会改变数组长度，
 delete b[0];//b在索引0的位置不再有元素
 b.length; //=>3;delete操作并不会影响数组长度

//使用pop()方法来删除元素，与push()配对使用；从数组的末尾删除一个元素，数组长度减一；并返回删除的元素
b.pop();//删除并返回b[2];

//使用shift();该方法与unshift()配对使用；从数组头部删除并返回删除的元素，后面的元素依次向前移动
b.shift();

//最后，splie()是一个通用的方法插入，删除，替换数组元素的方法；

/*创建多维数组，javascript中部支持真正的多维数组，但是可以用数组的数组来近似的表示*/
    //创建一个多维数组
    var table=new Array(10);//table有10行
    for(var i=0;i<table.length;i++){
        table[i]=new Array(10);//table有10列；这里得到啦一个table[10][10]的二维数组
    }
    for(var row=0;row<table.length;row++){
        for(var col=0;col<table[row].length;col++){
            table[row][col]=row*col;
        }
    }
    //使用多维数组查询结果
    var product=table[5][7];//35

/*遍历数组*/
var arr=[1,2,3,3,4];
//1.原生的for循环
for（var i=0;i<arr.length;i++）{
    //对数组进行操作
}
//2.for in循环
    for(var i in arr){
        //alert(arr[i]);
        //对数组进行操作
    }
//3.forEach
  var sum=0;
  arr.forEach(function(x){//把数组的每个元素传递给这个函数
      //sum+=x;
      //这里对数组中的元素进行操作
});
//最后说一点：如果考虑得性能的话，最好用原生的for循环。

数组方法

- join();

/*Array.join()方法将数组中的所有元素都转化为字符串并连接一起，最后返回生成的字符串，可以选择定一个字符串来分隔数组的各个元素，如果没有指定默认为逗号*/
var arr=[1,2,3];
a.join();//"1,2,3"
a.join("");//"123"
//Array.join()的逆向操作是Array.split()方法；后者是把字符串分割成若干块来创建一个数组

- reverse();

/*Array.reverse()方法是将数组中的元素颠倒顺序，返回逆序数组*/
var arr=[1,2,3];
arr.reverse();//=>"3,2,1"

- sort();

/*Array.sort()方法将数组中的元素排序并返回排序后的数组，当不带参数的调用sort（）时，数组元素以字母表顺序排列;如果数组中包含undefined元素，它们会排列在数组的尾部*/
var a=["banana","cherry","apple"];
a.sort();//=>"["apple","banana","cherry"]";

/*如果想按照自己想要的顺序排列的话，可以给sort（）传递一个比较函数；如果第一个参数要排在前面，应该返回一个小于0的数值，否则返回一个大于0的数值*/
var a=[33,4,1111,22];
a.sort();//=>1111,222,33,4;
a.sort(function(a,b){
    return a-b;
});//4,33,222,1111

- concat();

/*Array.concat()方法创建并返回一个新数组，它的元素包括调用concat（）的原始数组中的元素和concat()的每一个参数.如果这些参数中的任何一个自身是数组，则连接的是数组的元素，而非数组本身，但是要注意，concat()不会递归扁平化数组的数组，concat()也不会修改调用的数组*/
var a=[1,2,3];
a.concat();//返回[1,2,3];
a.concat(4,5);//返回[1,2,3,4,5];
a.concat([4,5]);//返回[1,2,3,4,5];
a.concat([4,5],[6,7]);//返回[1,2,3,4,5,6,7];
a.concat(4,[5,[6,7]]);//返回[1,2,3,4,5,[6,7]];

- slice();

/*Array.slice()方法返回指定数组的一个子片段或者子数组*/
var arr=[1,2,3,4,5]
//如果传入了两参数，Array。slice(startIndex,endIndex);返回索引从startIndex到endIndex-1的元素；
arr.slice(0,3);//返回[1,2,3];
//如果只传入一个参数，则返回这个索引到数组末尾的所有的元素
arr.slice(3);//返回[4,5];
//如果参数中出现负数，它表示相对数组最后一个元素的位置，例如：参数-1指定最后一个元素，
arr.slice(1,-1);//返回[2,3,4];
arr.slice(-3,-2);//返回[3]；

- splice();

/*Array.aplice()方法是在数组中插入或删除元素的通用方法，不同于slice(),concat().splice()会修改调用的数组*/
/*
    splice()的第一的参数指定了插入或删除的起始位置；第二个参数指定要删除的元素个数；如果省略了第二个参数，从起始点到数组末尾的所有元素都会被删除            
*/
var arr=[1,2,3,4,5,6,7,8];
a.splice(4);//返回[5,6,7,8];arr是[1,2,3,4];
a.splice(1,2)//返回[2,3];arr是[1,4];

//splice()的第三个或任意多个参数，指定了需要插入数组的元素
var a=[1,2,3,4,5];
a.splice(2,0,'a','b');//返回[];a是[1,2,'a','b',3,4,5];
a.splice(2,2,'[1,2],3);//返回['a','b'];a是[1,2,[1,2],3,3,4,5];

- push()&&pop();

/*push()和pop()方法允许将数组当栈来用*/
//push()方法在数组末尾添加一个或多个元素，并返回数组的新长度
//pop();方法则是从数组末尾删除一个元素，并返回删除的元素

- unshift()&&shift();

/*unshift()&&shift()将数组当队列来用*/
//unshift()；在数组的头部添加一个或多个元素，并且将已存在的元素往后移动，最后返回子新的数组长度
//shift();将数组的第一个元素删除并返回；然后将后面的元素向前移动

- toString&&toLocaleString();

/*数组和其他的javascript对象一样拥有toString()方法。针对数组，该方法将其的没有的元素转化为字符串*/
[1,2,3].toString();//输出1，2，3

/*toLocaleString()是toString()方法的本地化版本，它调用元素的toLocaleString()方法将每个数字元素转化为字符串，并且使用本地化的分隔符连接生成的字符串*/

ECMAScript 5中的数组方法

forEach();

/*forEach()方法从头到尾变遍历数组，为每个元素调用指定的函数。如上所述，传递的函数作为forEach()的第一个参数，然后forEach()使用三个参数调用该函数：数组元素，元素索引和数组本身*/
var data=[1,2,3,4,5];
//计算数组元素的值
var sum=0;
data.forEach(function(x){
    sum+=x;
});
//每个元素的值自加1
data.forEach(function(value,i,arr){
    arr[i]=value+1;
})
dara;//[2,3,4,5,6];
//注意：forEach()无法在所有元素都在传递给调用函数之前终止遍历。

map();

/*map()方法将调用的数组的每一个元素传递给指定的函数，并且返回一个数组，它包含该函数的返回值*/
var a=[1,2,3];
var b=a.map(function(x){
    return x*x;
});//b[1,4,9];
//注意：map()返回的是新数组，还有传递给map的函数应该有返回值

filter();

/*filter()方法用来过滤数组，filter（）接受一个函数用来逻辑判定，该函数返回的值为true或false；如果返回值为true，则该元素为新数组的一个成员*/
var a=[1,2,3,4,5];
var b=a.filter(function(x){
    return  x>3;
})//b[4,5];
//注意：filter（）会跳过稀疏数组中缺少的元素，它返回的总是稠密的。

every()&&some();

/*every()和some()方法是数组的逻辑判定；它们对数组元素应用指定的函数进行判定；返回值为true或false*/
//every()方法；针对所有；当且仅当针对所有的数组元素都返回true；才返回true；
a=[1,2,3];
a.every(function(x){
    return x>0;
})//返回true；
//some()方法；是存在量词；当数组中存在一个符合条件，就返回true；
a.some(function(x){
    return x<0;
});//返回false；

reduce()&&reduceRight()

/*reduce()&&reduceRight()方法使用指定的函数将数组元素进行组合,生成单个值*/
/*reduce()需要两个参数，第一个是执行化简操作的函数。化简函数的任务就是用某种方法把两个值组合或化简为一个值，并返回化简后的值。第二个（可选）的参数是一个传递给函数的初始值*/
var a=[1,2,3,4,5];
var sum=a.reduce(functon(x,y){
    return x+y;
},0);//sum=15;
//reduceRight()方法是按索引从高到低来合并数组的；和reduce（）一样的用途。

indexOf()&&lastIndexOf();

/*indexOf()和lastIndexOf()搜索整个数组中具有给定值的元素，返回找的的第一个元素的索引或如果找不到返回-1；indexOf（）从头到尾搜索；而lastIndexOf()则反向。它们接受两个参数：第一个参数表示要查找的元素；第二个参数表示一个索引，从该索引开始搜索；第二个参数可以省略；
*/
var a=[0,1,2,1,0];
a.indexOf(1);//返回值为1
a.lastIndexOf(1);//返回值为3；
a。indexOf(3);//返回值为-1；