JS数组常见的方法

左手的ㄟ右手 2022-03-12 13:38 241阅读 0赞

//改变原数组  
            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();