JavaScript部分方法及其重构

1、push()方法
向数组尾部添加一个或者多个元素，并且返回添加后的数组新长度

         var arr=[1,2,3];
         var len=arr.push(4);
         var len=arr.push(4,5,6,7);
         console.log(len,arr);

push()方法的重构：

function push(arr){
            if(arguments.length<1) return;
            if(arguments.length<2) return arr.length;
            for(var i=1;i<arguments.length;i++){
                arr[arr.length]=arguments[i];
            }
            return arr.length;
        }

2、pop()方法
删除数组的最尾部元素，并且返回这个被删除的元素

		var arr = [1, 2, 3, 4];
        var temp = arr.pop();
        console.log(temp);

pop()方法的重构：

function pop(arr) {
            var item = arr[arr.length - 1];
            arr.length--;
            return item;
        }
        var arr = [2, 3, 4]
        console.log(pop(arr), arr);

3、unshift()方法
在数组的最前面添加一个或者多个元素，并且返回数组的新长度

var arr = [1, 2, 3, 4];
var len = arr.unshift(5, 6, 7);
console.log(arr, len);

unshift()方法的重构

        function unshift(arr) {
            var len = arr.length - 1;
            for (var i = len; i >= 0; i--) {
                arr[i + arguments.length - 1] = arr[i];
            }
            for (var j = 1; j < arguments.length; j++) {
                arr[j - 1] = arguments[j];
            }
            return arr.length;
        }
        var len = unshift(arr, 5, 6, 7);

4、shift()方法
删除数组的第0项（第一个元素），并且返回被删除的元素

		 var arr=[2,3,4,5];
         var item=arr.shift();
         console.log(item,arr);

shift()方法的重构：

function shift(arr) {
            var item = arr[0];
            for (var i = 1; i < arr.length; i++) {
                arr[i - 1] = arr[i];
            }
            arr.length--;
            return item;
        }
        var arr = [2, 3, 4]
        console.log(shift(arr), arr);

5、splice()方法:
从什么位置开始、删除几个元素、在开始的位置添加元素…可以实现任意位置插入，任意位置删除，任意位置修改

		var arr = ["a", "b", "c", "d", "e", "f"];
		var arr1 = arr.splice(1);//从第一个开始，如果没有第二个以后的参数，默认从第一个删除到尾部
        var arr1 = arr.splice();//不删除，但是创建一个空数组返回
        var arr1 = arr.splice(0);//将arr数组中的元素转换到arr1中，
        var arr1 = arr.splice(-2);//如果开始位置有负数，则从后向前数
        var arr1 = arr.splice(-1);//如果开始位置有负数，则从后向前数，仅删除最后一位并且返回这个删除的数组
        var arr1 = arr.splice(2, 0);//指定删除0个，就是不删除
        var arr1 = arr.splice(2, 2);//指定删除2个，就是从下标是2开始向后删除2个元素
        var arr1 = arr.splice(2, 0, "g");//从下标为2开始，删除0个元素，添加一个"g"的元素，这就是删除
        var arr1 = arr.splice(2, 1, "g");//从下标为2开始，删除1个元素，并且在这个位置添加一个"g"的元素，这就是替换
        var arr1 = arr.splice(2, 0, "g", "h", "i");//
        var arr1 = arr.splice(2, 1, "g", "h", "i");//
        console.log(arr, arr1);

splice()方法的重构：

			function splice(arr, start, count) {
            if (start === undefined) start = count = 0;//如果start没有给，默认start从0开始count不删除
            if (start < 0) start = (arr.length + start >= 0 ? start + arr.length : 0);//如果start是负数，则转换为正数
            if (count === undefined) count = arr.length - start;//如果start有值，count没有值，默认是删除到数组的尾部
            var arr1 = [];//创建一个要删除的元素空数组
            for (var i = start; i < (start + count > arr.length ? arr.length : start + count); i++) {
                arr1[arr1.length] = arr[i];//将所有要删除的元素添加到这个空数组中，注意如果要删除的元素数量，超出了数组尾部，则默认删除到尾部
            }
            var arr2 = [];//创建一个删除元素后面形成的空数组
            for (var j = start + count; j < arr.length; j++) {
                arr2[arr2.length] = arr[j];//将所有需要挪位的元素放置在这个空数组中
            }
            arr.length = start;//将原数组删除到开始位置，仅保留开始之前的元素
            for (var k = 3; k < arguments.length; k++) {
                arr[arr.length] = arguments[k];//给数组添加需要插入的元素内容
            }
            for (var l = 0; l < arr2.length; l++) {
                arr[arr.length] = arr2[l];//给数组尾部添加原有没有删除的元素
            }
            return arr1;
        }
        var arr1 = splice(arr, 2, 2, "g");
        console.log(arr1, arr);

splice()重构方法二：

function splice(arr, start, count) {
            // 如果没有给入从什么下标开始，那么直接返回一个空数组
            if (start === undefined) return [];
            // 如果起始下标是负数  -2  用数组长度+这个负数下标就是正数的下标
            // 如果这个加完的值仍然小于0.就让他等于
            if (start < 0) start = (arr.length + start >= 0 ? arr.length + start : 0);
            // 如果没有给删除多少个元素，就让这个值默认为数组长度-开始的位置
            if (count === undefined) count = arr.length - start;
            start = parseInt(start);
            count = parseInt(count);
            // 因为数组需要产生删除或者添加，这样不能用数组长度做为循环条件
            var len = arr.length;
            var arr1 = [];//这是一个新数组，用来返回删除掉的元素
            // 从开始位置到数组尾部做循环
            for (var i = start; i < len; i++) {
                if (i < start + count) arr1[arr1.length] = arr[i];//把要删除的元素添加在新数组中
                else arr[i - count] = arr[i];//把后面的数据移动到前面
            }
            // arr.length-=(count>(len-start) ? len-start : count);
            arr.length -= count;//删除数组多余的长度
            len = arr.length - 1;//获取下标是长度-1；
            for (var j = len + arguments.length - 3; j >= start; j--) {
                if (j >= arguments.length - 3 + start) arr[j] = arr[j - (arguments.length - 3)];
                else arr[j] = arguments[3 + j - start];
                // 3是arguments的起始位置
                // j现在到原数组的尾部-state=count
            }
            return arr1;
        }


        var arr1 = splice(arr, 2, 2, "g");
        console.log(arr1, arr);

6、concat()方法：
连接，将数组与多个元素或者多个数组连接，返回一个新数组，原数组不变

		var arr = [1, 2, 3];
        var arr1 = arr.concat(5, 4, 6);
        var arr1 = arr.concat([4, 5, 6]);
        var arr1 = arr.concat([4, 5, 6], [7, 8, 9]);
        console.log(arr1, arr);

concat()方法重构：

		function concat(arr) {
            var arr1 = [];
            for (var i = 0; i < arguments.length; i++) {
                if (arguments[i] && arguments[i].constructor === Array) {
                    for (var j = 0; j < arguments[i].length; j++) {
                        arr1[arr1.length] = arguments[i][j];
                    }
                } else {
                    arr1[arr1.length] = arguments[i];
                }
            }
            return arr1;
        }

7、join()方法:
数组的各元素，以什么连接形成字符串返回

		var arr = [
            { a: 1 },
            { a: 2 },
            { a: 3 }
        ]
        var str = arr.join(undefined);//数组的各元素，以逗号连接形成一个字符串返回
        var str = arr.join("|");//数组的各元素，以竖杠连接形成一个字符串返回
        var str = arr.join("");//数组的各元素，以空字符连接形成一个字符串返回
        console.log(str);

join()方法的重构：

 			function join(arr, separator) {
            if (separator === undefined) separator = ",";
            var str = "";
            for (var i = 0; i < arr.length; i++) {
                if (i === arr.length - 1) str += arr[i];
                else str += arr[i] + String(separator);
            }
            return str;
        }

        var str = join(arr, "|");
        console.log(str);

8、slice()方法：
复制或者获取数组的从start开始到end结束之前下标的所有元素形成新数组

		var arr=[1,2,3,4,5];
       var arr1=arr.slice(2,4);
       console.log(arr1,arr);

slice()方法的重构：

			var arr = [1, 2, 3, 4, 5];
			function slice(arr, start, end) {
            if (start === undefined) start = 0;
            if (end === undefined) end = arr.length;
            if (start < 0) start = (start + arr.length > 0) ? start + arr.length : 0;
            if (end < 0) end = (end + arr.length > 0) ? end + arr.length : 0;
            if (end > arr.length) end = arr.length;
            var arr1 = [];
            for (var i = start; i < end; i++) {
                arr1[arr1.length] = arr[i];
            }
            return arr1;
        }

        var arr1 = slice(arr, 0, -1);
        console.log(arr1);


        var arr1 = slice(arr, 1, 10);
        console.log(arr1);

9、some()方法：
根据回调函数中返回的布尔值确定是否在数组中满足条件，如果有满足的就返回true，不继续判断。

var  arr=[1,2,3,4,5,6];
var bool=arr.some(function(item,index,arr){
            return item>3;});

some()方法的重构:

function some(arr,fn){
            for(var i=0;i<arr.length;i++){
                if(i in arr && fn(arr[i],i,arr))  return true;
            }
            return false;
        }

10、every()方法:
根据回调函数中返回的布尔值确定是否在数组中每一个都满足条件，如果有一个不满足直接返回false，不继续循环

var  arr=[1,2,3,4,5,6];
var bool=arr.every(function(item,index,arr){
            return item>2;
        })
        console.log(bool); 

every()方法的重构:

var  arr=[1,2,3,4,5,6];
function every(arr,fn){
            for(var i=0;i<arr.length;i++){
                if(i in arr && !fn(arr[i],i,arr))  return false;
            }
            return true;
        }