JS数组常见的方法

//改变原数组
            var arr = [];
            arr.push(10,123,456);//在数组的最后以为添加数据，返回数组的长度
            Array.prototype.push = function(){
                for(var i = 0; i < arguments.length; i++){
                    this[this.length] = arguments[i];
                }
                return this.length;
            }
            arr.pop();//剪切数组的最后以为并返回，传参不影响
            arr.unshift(-1,0);//在数组的开始添加数据，并返回数组的长度 
            arr.reverse();//将数组反转，改变原数组
            var arr1  = [1,1,2,2,3,3];
//            arr.splice(从第几位开始,截取多少的长度,在切口处添加新的数据);   返回截取的数组
            arr1.splice(1,2);//返回[1,2],arr1 = [1,2,3,3];
            arr1.splice(0,3);
            arr1.splice(1,1,0,0,0);//arr1 = [1,0,0,0,2,2,3,3]
            var arr2 = [1,2,3,5];//将4插入3和5之间
            arr2.splice(3,0,4);
            
            
            
            //sort
            var arr3 = [9,1,20,3,50,-9,-1];
            //arr3.sort();//按照阿斯克码排序
            
            //必须写俩形参
            //看返回值       （1）当返回值为负数时，前面的数放在前面
                    //（2）当返回值为整数时，后面的数放在前面
                    //（3）返回值为0时，顺序不变(冒泡排序)
                arr3.sort(function(a,b){
                return a - b;//升序
//                return b - a;//降序
             })
            
//            给一个有序数组乱序
            var arr4 = [1,2,3,4,5,6,7,8,9,10];
            arr4.sort(function(){
                return Math.random() - 0.5;
            });
            
            
            //对象排序
            var o1 = {
                name : "a",
                age : 44
            }
            var o2 = {
                name : "b",
                age : 22
            }
            var o3 = {
                name : "c",
                age : 34
            }
            var arr5 = [o1,o2,o3];
            arr5.sort(function(a,b){
                return a.age - b.age;
            })

            //不改变原数组
            var Arr1 = [1,2,3];
            var Arr2 = [4,5];
            var Arr = Arr1.concat(Arr2);//Arr1和Arr2并未改变
            var newArr1 = Arr.slice();//slice(从该位开始，截取到该位)并返回截取的数组，原数组不改变，如果直传一个参数，那么便从该位开始截取，截取到末位，不写参数，整个截取
            var str = Arr.join("-");//参数最好以字符串的形式，返回连接后的字符串
            var newArr2 = str.split("-");
            

            //类数组(具备数组和对象的属性)
            //属性要为（数字）属性
            //必须有length，最好有push方法

例题：
            var obj = {
                "2" : "a",
                "3" : "b",
                "length" : 2,
                "push" : Array.prototype.push,
                "splice" : Array.prototype.splice
            }
            obj.push("c");
            obj.push("d");

         console.log(obj);

    解析：
//            obj = {
//                "2" : "c",
//                "3" : "d",
//                "length" : 4 
//            }

obj是类数组，其push方法如下

//            Array.prototype.push = function(target){
//                this.[this.length] = target;
//                this.length++;
//            }

现在length == 2;故arr.push("c")即

 obj = {
 "2" : "c",
  "3" : "b",
  "length" : 3， 
   }此时legnth++，length == 3；

同理arr.push("d"),即

            obj = {
                "2" : "c",
                "3" : "d",
                "length" : 4 
           }此时length == 4

 

 

    //数组去重
            var unarr = [1,"a",1,2,3,2,3,"a","a"];
            Array.prototype.unique = function(){
                var obj = {},
                    myArr = [],
                    len = this.length;
                for(var i = 0;i < len; i++){
                    if(!obj[this[i]]){
                        obj[this[i]] = "1";
                        myArr.push(this[i]);
                    }
                }
                return myArr;
            }

unarr.unique();