js中數組常用方法的簡單重構(部分)，幫助你加快理解數組中常用方法

將指定數字插入到數組的末尾,返回值為將數組的第一個元素刪除並返回，返回值為 ...

`push`

將指定數字插入到數組的末尾,返回值為新數組的長度

    //原方法示例:
    var ary = [1, 2, 3, 4, 5];
    ary.length = 5;
    ary.push(1) ;
    ary = [1,2,3,4,5,1];
    ary.length = 6;

   //方法重構:
Array.prototype.myPush = function () {
    for (i = 0; i < arguments.length; i++) {
        this[this.length] = arguments[i];
    }
    return this.length
}

`pop`

將數組最後的元素刪除，返回值為刪除掉的元素

    //原方法示例:
    var ary = [1, 2, 3, 4, 5];
    var num = ary.pop();
    console.log(num); == 5

    //方法重構:
Array.prototype.myPop = function () {
    var num = this[this.length - 1];
    this.length--
    return num
}

`unshift`

將指定的數字插入到元素的前面，返回值為新數組的長度

    //原方法示例:
    var ary = [1, 2, 3, 4, 5];
    ary.length = 5;
    ary.unshift(1) ;
    ary = [1,1,2,3,4,5];
    ary.length = 6;

    //方法重構:
Array.prototype.myUnshift = function () {
    var len = this.length; //用一個變數存儲原來的數組的長度
    this.length += arguments.length; //傳入進來幾個參數，數組的長度就增加傳入進來的參數的長度
    for (var i = 0; i < arguments.length; i++) {
        /* 整體需要進行幾輪的迴圈，迴圈的輪數應該與傳入進來的實參長度相等，因為第一輪的時候只是將數組整體往後面移了一個位置，想要前面能夠有足夠實參插入的長度，那麼迴圈的輪數就是由實參的長度所確定的*/
        for (var j = len; j > 0; j--) {
            /* 因為往前面插入，所以將數組的中原來的值往後移動，並且從最後一位開始移動才能使數組中的元素不被覆蓋 */
            this[j] = this[j - 1];
            /* 讓後面為空的元素等於前面的值，將數組的值依次往後移動 */
        }
        len++; /* 內部迴圈完畢後，此時的原數組的最後一位已經往後移動了一位，如果還需要將數組往後繼續進行移動的話，那麼就應該從原數組的最後一位繼續往後移動，所以此時的len就應該加一。如果不進行加一操作的話，會把後面的元素覆蓋掉，並且整個數組將不會再往後移動，後面都是空元素 */
    }
    return this.length
}

`shift`

將數組的第一個元素刪除並返回，返回值為被刪除的元素

    //原方法示例:
    var ary = [1, 2, 3, 4, 5];
    var num = ary.shift();
    console.log(num); === 1

    //方法重構:
Array.prototype.myShift = function () {
    var num = this[0];
    var len = this.length;
    for (var i = 0; i < len; i++) {
        this[i] = this[i + 1];
    }
    this.length--;
    return num
}

`concat`

將數組進行拼接，返回值是拼接後的數組(傳入的參數中有數組，並且其中存在空元素，空元素也會進行拼接)

    //原方法示例:
    var ary = [1, 2, 3, 4, 5];
    var ary1 = ary.concat([1, 2, 3, , 4], {a:1})
    console.log(ary1) === [1, 2, 3, 4, 5, 1, 2, 3, , 4, {a:1}]

    //方法重構:
Array.prototype.myConcat = function () {
    var ary = this;
    for (var i = 0; i < arguments.length; i++) {
        if (arguments[i].constructor === Array) {
            for (var j = 0; j < arguments[i].length; j++) {
                ary[ary.length] = arguments[i][j];
            }
        } else {
            ary[ary.length] = arguments[i];
        }
    }
    return ary
}

`join`

將數組用傳入的參數進行拼接，返回值為拼接後的字元串(不傳入參數，預設為"")

    //原方法示例:
    var ary = [1, 2, 3, 4, 5];
    var str = ary.join();
    console.log(str) === "1,2,3,4,5"

    //方法重構:
Array.prototype.myJoin = function () {
    var str = "";
    if (arguments[0] === "" || arguments[0] === undefined) {
        for (i = 0; i < this.length - 1; i++) {
            str += this[i] + ",";
        }
    } else {
        for (i = 0; i < this.length - 1; i++) {
            str += this[i] + arguments[0];
        }
    }
    str += this[this.length - 1];
    return str
}

`some`

第一個傳入的參數為一個函數，該函數有三個參數，分別為item、index、ary，將該函數執行，返回執行結果，如果結果中有一個true結束運行，沒有true將一直查找下去。返回值為布爾值

    //原方法示例:
    var ary = [1, 2, 3, 4, 5];
    var bool = ary.some(function(item,index,ary){
        return item > 4;
    })// true

    //方法重構:
Array.prototype.mySome = function () {
    for (var i = 0; i < this.length; i++) {
        var bool = arguments[0](this[i], i, this);
        if (bool) return true;
    }
    return false;
}

`every`

第一個傳入的參數為一個函數，該函數有三個參數，分別為item、index、ary，將該函數執行，返回執行結果，如果結果中有一個false結束運行，沒有false將一直查找下去。返回值為布爾值

    //原方法示例
    var ary = [1, 2, 3, 4, 5];
    var bool = ary.every(function(item,index,ary){
        return item > 1;
    })// false

    //方法重構
Array.prototype.myEvery = function () {
    for (var i = 0; i < this.length; i++) {
        var bool = arguments[0](this[i], i, this);
        if (!bool) return false;
    }
    return true;
}

`slice`

可傳入兩個參數，第一個參數代表這起始下標位置,第二個參數選填,代表到這個數字下標前結束.

不傳參數，預設截取到末尾,參數也可為負數.

返回值截取的數組成的數組,原數組不變

    //原方法示例：
    var ary = [1, 2, 3, 4, 5];
    ary.slice() ===> [1, 2, 3, 4, 5];
    ary.slice(1,3) ===> [2, 3]
    ary.slice(-3,-1) ===> [3, 4]

    //方法重構：
Array.prototype.mySlice = function () {
    /* 
    分為兩種情況：
    1、當arguments[1]為0時,或者為undefined時,此時有以下情況：
        1、如果此時的arguments[1]是undefined時有以下情況：
            1、當arguments[0]大於等於0時,從arguments位下標開始往後截取
            2、當arguments[0]為undefined時,複製一份原數組
            3、其他情況都返回空數組
    2、當arguments[1]為true時，有以下情況：
        1、正常情況下，當arguments[0]小於等於arguments[1]時，有以下情況
            1、兩個參數都是大於0的情況下(arguments[0]可等於0)，從arguments[0]位下標開始複製到arguments[1]位下標前一位結束
            2、兩個參數都小於0時，此時的開始位置(arguments[0])和結束位置(arguments[1])應該都加上數組的長度
        2、除去上面的情況，都為非正常情況，所以都返回空數組
    */
    var ary = [];
    if (arguments[1] > this.length) arguments[1] = this.length;
    //判斷傳入的第二個參數是否超出數組的長度，如果超出，則讓它預設為數組的長度
    if (!arguments[1]) {
        //當argumens為0或者不傳時
        if (typeof arguments[1] === 'undefined') {
            //判斷當argumens[1]是否為undefined,如果是,進入此語句
            if (arguments[0] >= 0) { //當argumens[0]
                for (var i = arguments[0]; i < this.length; i++) {
                    ary[ary.length] = this[i];
                }
                return ary
            } else if (typeof arguments[0] === 'undefined') {
                for (var j = 0; j < this.length; j++) {
                    ary[ary.length] = this[i];
                }
                return ary
            }
        } else return ary //除去上述情況都為非正常情況，返回空數組

    } else {
        //否則當argument[1]>0時進入此語句
        if (arguments[0] <= arguments[1]) {
            //正常情況下開始位置總會小於等於結束位置
            if (arguments[0] >= 0 && arguments[1] > 0) {
                //第一種情況：兩個都大於0時(arguments[0]可以等於0)
                for (var k = arguments[0]; k < arguments[1]; k++) {
                    //直接複製
                    ary[ary.length] = this[k];
                }
                return ary
            } else if (arguments[0] < 0 && arguments[1] < 0) {
                //第二種情況：兩個都小於0時
                for (var n = arguments[0] + this.length; n < arguments[1] + this.length; n++) {
                    //首先需要將兩個負的參數都加上數組的長度變為正
                    ary[ary.length] = this[n];
                }
                return ary
            } else return ary //除去上述情況都為非正常情況，返回空數組
        } else return ary //除去上述情況都為非正常情況，返回空數組  
    }
}

`forEach`

將數組中的每一項進行遍歷，不遍歷空元素，無返回值

Array.prototype.myForEach = function () {
    var len = this.length-1;
    for (var item in this) {
        if (len === 0) break;
        arguments[0](this[item],item,this);
        len--;
    }
}

`map`

將數組中的每一項進行遍歷，返回一個與原數組長度相同的數組

    // 原方法示例：
    var ary = [1, 2, 3, 4, 5];
    ary.map(function(item,index,ary){
        return item * 2
    }) === [2,4,6,8,10]

    // 方法重構：
Array.prototype.myMap = function () {
    var ary = [];
    ary.length = this.length;
    var len = ary.length-1;
    for (var item in this) {
        if (len === 0) break;
        ary[item] = arguments[0](this[item],item.this);
        len--;
    }
    return ary
}

`filter`

第一個傳入的參數為一個函數，函數中可傳入三個參數，分別為item、index、ary，返回值是一個由所有滿足條件的元素所組成的數組

    //原方法示例：
    var ary = [1, 2, 3, 4, 5];
    ary.filter(function(item,index,ary){
        return item > 2
    }) === [3,4,5]

    //方法重構：
Array.prototype.myFilter = function () {
    var ary = [];
    for (var i = 0; i < this.length; i++) {
        var bool = arguments[0](this[i], i, this);
        if (bool) {
            ary[ary.length] = this[i];
        }
    }
    return ary
}

`reduce`

第一個傳入的參數為一個函數，函數中可傳入四個參數，分別為value、item、index、ary，返回計算後第一個參數的值，返回值為一個值

如果有傳入第二個參數，那麼第一個參數的第一個參數的預設值就為它，並且第一個參數的第二個參數從數組的第0位起始;

否則，未傳入，那麼第一個參數的第一個參數就時數組的第0位，並且第一個參數的第二個參數從數組的第1位起始

    //原方法示例：
    var ary = [1, 2, 3, 4, 5];
    var num = ary.reduce(function(value,item,index,ary){
        return value + item;
    })
    console.log(num) === 15

    //方法重構：
Array.prototype.myReduce = function () {
    var initValue;
    var i = 0;
    if (arguments[1] || arguments[1] === 0) {
        initValue = arguments[1];
    } else {
        initValue = this[0];
        i++;
    }
    while (i < this.length) {
        initValue = arguments[0](initValue, this[i], i, this);
        i++;
    }
    return initValue;
}

`reduceRight`

第一個傳入的參數為一個函數，函數中可傳入四個參數，分別為value、item、index、ary，返回計算後第一個參數的值，返回值為一個值

如果有傳入第二個參數，那麼第一個參數的第一個參數的預設值就為它，並且第一個參數的第二個參數從數組的第length-1位起始;

否則，未傳入，那麼第一個參數的第一個參數就時數組的第length-1位，並且第一個參數的第二個參數從數組的第length-2位起始

    //原方法示例：
    var ary = [1, 2, 3, 4, 5];
    var num = ary.reduceRight(function(value,item,index,ary){
        return value + item;
    })
    console.log(num) === 15

    //方法重構：
Array.prototype.myReduceRight = function () {
    var initValue;
    var i = this.length - 1;
    if (arguments[1] || arguments[1] === 0) {
        initValue = arguments[1];
    } else {
        initValue = this[this.length - 1];
        i--;
    }
    while (i >= 0) {
        initValue = arguments[0](initValue, this[i], i, this);
        i--
    }
    return initValue
}