javascript中数组方法(未完待续)

  一、sort()方法：将数组中的元素排序并返回排序后的数组。
                    1、当不带参数调用sort()时，数组元素以字母表顺序排序
                     （如有必要将临时转化为字符串进行比较）
                    */
                    var a=new Array("banana","everyday","cherry","apple","zIndex");
                        a.sort();
                        var s=a.join(", ");
                        //console.log(s); //apple, banana, cherry, everyday, zIndex
                        //如果数组包含undefined元素，它们会被排到数组的尾部
                        /*
                    2、为了按照其他方式而非字母表顺序进行 数组排序，必须给sort()方法
                       传递一个比较函数。如：                       
                    */
                    var a=[33,4,1111,222];
                    a.sort(function(a,b){
                        return a-b;// 返回负数，则a排在b的前面;返回正数则a排在b的后面。(返回a-b，则正序排列；返回b-a则倒序排列)
                    });
                    console.log(a);// [4, 33, 222, 1111]
                    /*
                    二、concat()方法 创建并返回一个新数组，它的元素包括调用concat()的原始数组的元素和concat()的每个参数。如果这些参数中的任何
                    一个自身是数组，则连接的是数组元素，而非数组本身。但要注意，
                    concat()不会递归扁平化数组的数组。concat()也不会修改调用的数组。例如：
                    */
                    var a=[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]]*/
                    var b=a.concat(5,3); //如有相同的值，也会加进去
                    /*
                    三、slice()
                    Array.slice()方法返回指定数组的一个片段或子数组。
                    它的两个参数分别指定了片段的开始和结束的位置。返回的数组包含第一个参数指定的位置和所有到但不包含第二个参数指定的位置之间的所有数组元素。
                    如果只指定一个参数，返回的数组将包含从开始位置到数组结尾的所有元素。
                    参数中出现负数，它表示相对于数组中最后一个元素的位置。(参数-1指定了最后一个元素，二-3指定了倒数第三个元素)
                    slice()不会修改调用的数组。例如：
                    */
                    var a=[1,2,3,4,5];
                    a.slice(0,3);//[1,2,3]
                    a.slice(3);//[4,5]
                    a.slice(1,-1); //[2,3,4]
                    a.slice(-3,-2);//[3]
                    /*
                    四、splice()
                        splice()方法是在数组中插入或删除元素的通用方法。
                        splice()方法会修改调用的数组。splice()能够从数组中删除元素、插入元素到数组中或者同时完成这两种操作。
                        在插入或删除点之后的数组元素会根据需要增加或减小它们的索引值，因此数组的其他部分仍然保持连续。
                        splice()的第一个参数指定了插入和(或)删除的起始位置。
                        第二个参数指定了应该从数组中删除的元素的个数。如果省略第二个参数，从起始点开始到数组结尾的所有元素都将被删除。
                        splice()返回一个由删除元素组成的数组，或者如果没有删除元素就返回一个空数组。例如：
                    */
                    var a=[1,2,3,4,5,6,7,8];
                        a.splice(4); //返回删除的元素，即:[5,6,7,8];a是[1,2,3,4]
                        a.splice(1,2);//返回[2,3];a是[1,4]
                        a.splice(1,1); //返回[4];a是[1]
                        //splice()的前两个参数指定了需要删除的数组元素 。紧随其后的任意个数的参数指定了需要插入到数组中的元素，从第一个参数指定的位置开始插入。例如：
                        var a=[1,2,3,4,5];
                        a.splice(2,0,"a","b");//[1,2,"a","b",3,4,5]
                        a.splice(2,2,[1,2],3); //返回[1,2,[1,2],3,3,4,5]
                    //注意，区别于concat(),splice()会插入数组本身而非数组的元素。
                    /*
                    五、unshift()和shift()
                    unshift()在数组的头部添加一个或多个元素，并将已存在的元素移动到更高索引的位置来获得足够的空间，最后返回数组新的长度。
                    shift()删除数组的第一个元素并将其返回，然后把所有随后的元素下移一个位置来填补数组头部的空缺。
                    */
                    /*
                    六、push()和pop()
                      push()方法在数组的尾部天机一个或多个元素，并返回数组新的长度。
                      pop()方法则相反：它删除数组的最后一个元素，减小数组的长度并返回它删除的值。注意，两个方法都修改并替换原始数组二非生成一个修改版的新数组。
                    */
                    /*
                    七、toString()和toLocaleString()
                    针对数组，该方法将其每个元素转化为字符串(如有必要将调用元素的toString()方法)并且输出用逗号分隔的字符串列表。注意，输出不包括方括号或其他任何形式的包裹数组值的分隔符。 
                    */
                    [1,2,3].toString() //生成'1,2,3'
                    ["a","b","c"].toString()//生成'a,b,c'
                    [1,[2,'c']].toString() //生成'1,2,c'
                   //这里与不是用任何参数调用join()方法返回的字符串是一样的。
                   八、forEach()
                      forEach()方法从头至尾遍历数组，为每个元素调用指定的函数。forEach()使用三个参数调用该函数：数组元素、元素的索引和数组本身。
                      var data=[1,2,3,4,5];
                      //计算数组元素的和值
                      var sum=0;
                      data.forEach(function(value){
                            sum+=value;
                      });
                      sum   //15
                       //每个数组元素的值自加1
                      data.forEach(function(v,i,a){  // v: 当前循环的数组元素；i：索引；a：数组本身。
                                   a[i]=v+1;
                              }
                              
                     );
                   九、map()
                     将调用的数组的每个元素传递给指定的函数，并返回一个数组，它包含该函数的返回值。
                     var a=[1,2,3];
                     var b=a.map(function(x){ return x*x }); //b是[1,4,9]
                     map返回的是新数组，它不修改调用的数组。 如果是稀疏数组，则返回相同方式的稀疏数组。
                   十、filter()
                      filter()方法返回的数组元素是调用的数组的一个子集。传递的函数是用来逻辑判定的：该函数返回true或false;如果返回值为true或
                       能转化为true的值，那么传递给判定函数的元素就是这个子集的成员,它将被添加到一个作为返回值的数组中。
                      var a=[5,4,3,2,1];
                      smallvalues=a.filter(function(x){
                              return x<3;     
                    });//[2,1]
                    filter()会跳过稀疏数组中缺少的元素，它的返回数组总是稠密的。
                  十一、every()和some()
                      every()和some()方法是数组的逻辑判定：它们对数组元素应用指定的函数进行判定，返回true或false;
                      every()：当且仅当针对数组中的所有元素调用判定函数都返回true,它才返回true:
                      var a=[1,2,3,4,5];
                      a.every(function(x){
                                 return x<10;
                      });// true;a中的所有元素都小于10
                      a.every(function(x){
                            return x%2===0;
                     }); // false;不是所有的值都是偶数
                     some(): 当数组中至少有一个元素调用判定函数返回true,它就返回true;当且仅当数值中的所有元素调用判定函数都返回false,
                             它才返回false:
                     var a=[1,2,3,4,5];
                     a.some(function(x){
                           return x%2===0;
                   }); //true;   a含有偶数
                  一旦every()和some()确认该返回什么值它们就会立即停止遍历数组元素。
                十二、reduce()和reduceRight()
                     reduce()和reduceRight()方法使用指定的函数将数组元素进行合并，生成单个值。这在函数式编程中是常见的操作，也可以称为"注入"和"折叠"。
                     reduce()需要两个参数。第一个是执行化简操作的函数。
                     化简函数的任务就是用某种方法把连个值组合或化简为一个值，并返回化简后的值。
                     第二个参数(可选)是一个传递给函数的初始值。如果没有指定初始值，默认将数组的第一个元素作为其初始值。
                     在空数组上，不带初始值参数调用reduce()将导致类型错误。
                     var a=[1,2,3,4,5];
                     var sum=a.reduce(function(x,y){ return x + y },0);