数组

数组三种创建方法：

　　var arr0 = [];                                //  字面量方法创建

　　var arr1 = new Array();　　　　 //   构造函数实例化对象

　　var arr2　= Array();　　　　　  //   字符串转数组类型

　　delete可以删除数组中的元素，因为数组就是伪对象,删除之后元素为empty，不会破环数组的紧密性

 

重构栈方法：

　　push(推入最后一项，返回数组新长度)、pop(弹出最后一项，返回弹出的值)：

 

        // 重写push方法：
         var arr = [1,2,3];
        function push(arr){
            for(var i=1; i<arguments.length;i++){
                arr[arr.length]  = arguments[i];
            }
            return arr;
        }
    
        console.log(push(arr,4,5,6));   
        // 结果为 [1,2,3,4,5,6]

        // 重写pop方法
        var arr = [1,2,3];
        function pop(arr){
            var item = arr[arr.length-1];
            arr.length--;
            return item;
        }
        console.log(pop(arr),arr); 
        // 结果为[1,2] 3
    

 

 

 

重构队列方法：

　　unshift(推入第一项，返回数组新长度)、shift(取出第一项，返回取出的值)：

 

        // 重写unshift方法
        var arr = [1,2,3,4];
        function unshift(arr){
            var len = arguments.length-1;
            for(var i= arr.length-1;i>=0;i--){
                arr[i+len] = arr[i];
            }
            for(var j=1;j<arguments.length;j++){
                arr[j-1] = arguments[j];
            }
            return arr;

        }
        console.log(unshift(arr,4,5,6)); 
        //   结果为 [4,5,6,1,2,3,4]

        // 重写shift方法
        var arr = [1,2,3,4];
        function shift(arr){
            var item = arr[0];
            for(var i =0;i<arr.length;i++){
                arr[i] = arr[i+1];
            }
            arr.length--;
            return item;
        }
        console.log(shift(arr),arr); 
        //  结果为 [2,3,4]
    

 

 

重排序方法：

　　reverse()、sort()，这两个方法都会调用toString()方法，然后比较得到后的字符串，即使每一项是数字，比较的也是字符串。

        var arr = [0,1,10,5,15,9];

        console.log(arr.reverse());  //  [ 9, 15, 5, 10, 1, 0 ] 

        console.log(arr.sort());      //  [ 0,  1, 10, 15, 5, 9]

　　sort()方法可以接收一个比较函数作为参数，以便确定哪个值位于哪个值的前面。

        var arr = [0,1,10,5,15,9];
        function compare(value1,value2){
            if(value1 < value2){
                return -1;
            }else if (value1 > value2){
                return 1;
            }else{
                return 0;
            }
        }
        
        console.log(arr.sort(compare).toString());    
        // 输出结果  [0,1,5,9,10,15]

操作方法：

　　concat() 连接  、splice(index,howmany,element1,......elementx)  删除 、插入、替换 。index:必需，从何处添加或删除元素；howmany:删除多少元素，可以是0，也可以不写，表示从index删除到最后，elment1-elmentx表示添加的新元素。返回被删除元素的数组。slice(strat,end)，表示从strat截取到end但不包含end，而且slice()不改变原数组。

 　　

 1         var colors = ["red", "green", "blue"];
 2          var removed = colors.splice(0,1);               
 3          // 删除第一项 alert(colors);     
 4          // green,blue alert(removed);    
 5          // red，返回的数组中只包含一项 
 6  
 7         removed = colors.splice(1, 0, "yellow", "orange");   
 8         // 从位置 1 开始插入两项 alert(colors);    
 9         // green,yellow,orange,blue alert(removed);    
10         // 返回的是一个空数组 
11  
12         removed = colors.splice(1, 1, "red", "purple");      
13         // 插入两项，删除一项 alert(colors);    
14         // green,red,purple,orange,blue alert(removed);    
15         // yellow，返回的数组中只包含一项                             

 

位置方法：

　　indexof()、lastIndexof()。这两个方法都接收 两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中，indexOf()方法从数组的开头（位 置 0）开始向后查找，lastIndexOf()方法则从数组的末尾开始向前查找。 indexof()、lastIndexof()这两个方法都是用全等比较。

 

迭代方法：

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

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

　　forEach()：对数组中的每一项运行给定函数。这个方法没有返回值。不遍历空元素，也不遍历属性

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

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

　　for-in()：循环可以把数组的可枚举属性遍历到

　　注意： delete删除数组元素，不会造成数组的自动收缩，紧密，数组的长度不会发生改变

归并方法：

　　reduce()和 reduceRight()。这两个方法都会迭 代数组的所有项，然后构建一个终返回的值。其中，reduce()方法从数组的第一项开始，逐个遍历 到后。而 reduceRight()则从数组的后一项开始，向前遍历到第一项。

 传给 reduce()和 reduceRight()的函数接收 4 个参数：前一个值、当前值、项的索引和数组对象。这 个函数返回的任何值都会作为第一个参数自动传给下一项。

将类数组转换为数组的方法：

　　 var  inputs = document.getElementsByTagName("input");

　　ES5  

　　　　var  list = Array.prototype.slice.call(inputs);

　　　　var  list = [].slice.call(inputs);

　　　　var  list = Array.prototype.concat.apply([],divs);

　　　　var  list = [].concat.apply([],divs);

　　ES6

　　　　var  list = Array.from(inputs);