引用类型-Array类型

ECMAScript数组的每一项可以保存任何类型的数据，并且数组的大小是可以动态调整的。

创建数组的基本方式有两种，第一种是使用Array构造函数

         var colors = new Array();

创建一个含有二十项的数组

1        var colors = new Array(20);

创建一个包含三项的数组

          var colors = new Array("pink","black","white");

当然也可以省略new操作符

1          var colors = Array(3);

创建数组的第二种基本方式是使用数组字面量表示法

          var colors = ["red","blue","green"];

数组的项数保存在length属性中，他不是只读的，因此通过设置这个属性，可以从数组的末尾移除项或向数组添加新项

          colors = 2;
          console.log(colors[2]); //undefined

检测数组

---

对于一个网页或者一个全局作用于而言，使用instanceof操作符就能得到满意的结果

         if(colors instanceof Array){//在不同的框架中传输时有问题！
             alert("This is a Array");
         }
         

ECMAScript5中新增加的方法！（不用管数组是在哪个全局执行环境中创建的）

         if(Array.isArray(colors)){//
             alert("This is a Array");
         }

转换方法

---

所有对象都具有toLocaleString()、toString()、valueOf()方法。其中，调用数组的toString()方法会返回由数组中每个值的字符串形式拼接而成的一个以逗号分割的字符串。而调用valueOf()返回的还是数组。实际上，为了创建这个字符串会调用每一项的toString()方法

         var colors = ["red", "blue" ,"green"];
         console.log(colors.toString());//red,blue,green 调用每一项的toString方法！
         alert(colors.valueOf()); //red,blue,green
         alert(colors); //red,blue,green

toLocaleString()方法经常也返回与toString()和valueOf()方法相同的值，但也不总是如此。当调用数组的toLocaleString()方法时，他也会创建一个数组值的以都好分割的字符串，与之前不同的是他会调用每一项的toLocaleString()方法，而不是roString()方法

         var person1 = {
             toLocaleString:function(){
                 return "Nikolaos";
             },
             toString:function(){
                 return "Nicholas";
             }
         };
         var person2 = {
             toLocaleString:function(){
                 return "Grigorios";
             },
             toString:function(){
                 return "Greg";
             }
         };
          var people = [person1,person2];
         alert(people);     // Nicholas,Greg
         console.log(people.toString());//Nicholas,Greg
         console.log(people.toLocaleString());//Nikolaos,Grigorios 

join()方法，可以使用不同的分隔符来构建这个字符串，如果不给join()方法传入任何值，或者给他传入undefined，则使用逗号作为分隔符

         var colors = ["red", "blue" ,"green"];
         console.log(colors.join("||")); //red||blue||green

栈方法

---

栈是一种LIFO（Last-In-First-Out）的数据结构，也就是最新添加的项最早被移除

push()方法可以接受任意数量的参数，把他们逐个添加到末尾，并返回修改后数组的长度

pop()方法从数组的末尾移除一项，减少数组的length值，并返回移除的项

         var colors = new Array();
         var count = colors.push("red","green");
         alert(count);//
         var item = colors.pop();
         alert(colors); //"red"
         alert(item); //"green"
                 

队列方法

---

队列数据结构的访问规则是FIFO（First-In-First-Out）。对列在列表的末端添加项，在列表的前端移除项

shift()能将数组的第一项移除并返回该项，同时数组的长度减1

unshift()会在数组的的前端加任意项，返回数组的长度

         var colors = new Array();
         var count = colors.push("red","green");
         var item = colors.shift();
          alert(item);// red
         var item = colors.unshift("black","pink");
         alert(item);//
         alert(colors);//black pink  green

同时使用unshift和pop方法可以以相反的方向来模拟队列

         var colors = new Array();
         var count = colors.unshift("green","black");
         alert(count);//
         var count = colors.unshift("pink","white");
         alert(count);//
         var item = colors.pop();
         alert(item);// black

重排序方法

---

reverse()会反转数组的顺序

sort()会调用每个数组项的toString()方法，然后再按升序排列数组。sort() 可以接受一个比较函数作为参数

         var num = [1,2,3,4,10,15];
         num.reverse();
         alert(num); //15,10,4,3,2,1

         num.sort();
         alert(num);//1,10,15,2,3,4

简单的比较函数

         function compare(result1,result2){
             if(result1<result2){
                 return -1;
             }
             else if(result1>result2){
                 return 1;
             }
             else{
                 return 0;
             }
         }
         var values = [0,1,5,9,7,10,11];

         console.log(values.sort(compare));// [0, 1, 5, 7, 9, 10, 11] 

更简单的方法

         function compare(result1,result2){
             return result1-result2;
         }

           num.sort(compare);
           alert(num);//1,2,3,4,10,15

操作方法

---

concat()会基于当前数组的所有项创建一个新的数组，具体来说就是，这个方法会创建当前数组的一个副本，然后将接收到的参数添加到这个副本的末尾，最后返回新构建的数组

         var colors = ["red", "green","black"];
         var colors2 = colors.concat("yellow","white");
         alert(colors2); //red green black yellow white

slice()接受一或者两个参数，即要返回项的起始位置和结束位置，如果只有一个参数，slice()方法返回从该参数指定位置开始到当前数组末尾的所有项

         var colors = ["red", "green","black"];
         var colors3 = colors.slice(1,2);
         alert(colors3); //green black

splice()的主要用途是向数组的中部插入项

splice()接受两个参数时：删除（删除第一项的位置，删除的项数）
　　　　　  三个参数时：插入（插入的位置，0，插入的项1，插入的项2......）
　　　　 　 三个参数时：替换（替换的位置，1，加入的项）

         var colors = ["red", "green","black"];
         var colors4 = colors.splice(1,1);
         alert(colors4); //green
         alert(colors);//red black
         var colors4 = colors.splice(1,0,"yellow");
         alert(colors);// red yellow black
         var colors4 = colors.splice(1,1,"pink");
         alert(colors);//red pink black

位置方法

indexOf()和lastIndexOf()接受两个参数（查找的项，查找开始的位置），其中indexOf()是从数组的开头开始向后查找，而lastIndexOf()是从数组的末尾开始向前查找。这两个方法返回要查找的项在数组当中的位置，或者在没有找到的情况下返回-1。在查找时会使用全等操作符

         var numbers = [1,2,3,4,5,4,3,2,1];
         var item = numbers.indexOf(4);
         alert(item);//
         alert(numbers.lastIndexOf(4));//
         alert(numbers.indexOf(4,4));//

         var person = {name:"Nicholas"};
         var morePerson = [person];
         alert(morePerson.indexOf(person));//

迭代方法

---

ECMAScript5为数组定义了5个迭代方法，每个方法都接受两个参数：要在每一项上运行的函数和运行该函数的作用域对象-影响this的值，传入这些方法中的函数接受三个参数：数组项的值、该项在数组中的位置和数组对象本身

every():对数组中的每一项运行给定函数，如果该函数对每一项都返回true,则返回true

         var numbers = [1,2,3,4,5,4,3,2,1];
         var everyResult = numbers.every(function(item,index,array){
              return (item>2);
          })
         alert(everyResult);//false

some():对数组中的每一项运行给定函数，如果该函数对任一项返回true,则返回true

         var someResult = numbers.some(function(item,index,array){
             return(item>2);
         })
         alert(someResult);//true

filter():对数组中的每一项运行给定函数，返回该函数会返回true的项组成的数组

         var filterResult = numbers.filter(function(item,index,array){
             return(item>2);
         })
         alert(filterResult); //3,4,5,4,3

map():对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组

         var mapResult = numbers.map(function(item,index,array){
             return(item*2);
         })
         alert(mapResult);//2,4,6,8,10,8,6,4,2

forEach():对数组中的每一项运行给定函数

         numbers.forEach(function(item,index,array){
             //执行某些操作
         })

归并方法

reduce()和reduceRight()这两个方法都会迭代所有数组的项，然后构建一个最终返回的值。其中，reduce()方法从数组的第一项开始，逐个遍历到最后，而reduceRight()正好相反，是从数组的最后一项开始，向前遍历到第一项。这两个方法都接受两个参数：一个在每一项上调用的函数和（可选的）作为归并基础的初始值。调用的函数接受4个参数：前一个值、当前值、项的索引和数组对象。第一次迭代发生在数组的第二项上

使用reduce()方法可以执行求数组中所有值之和的操作

         var results = [1,2,3,4,5];
         var sum = results.reduce(function(prev,cur,index,array){
             return prev+cur;
         }) ;
         alert(sum);//

         var sum = results.reduceRight(function(prev,cur,index,array){
             return prec+cur;
         })
         alert(sum);//