JS数组方法的原生实现

一、push方法

该方法接受任意个参数，然后添加到数组的末尾

function push(arr, ...arg)//push 接受任意个参数，按照顺序添加到数组末尾，返回新的数组长度
{
    for (let i = 0; i < arg.length; i++) {
        arr[arr.length++] = arg[i];
    }
    return arr.length;
}

二、pop方法

该方法删除并返回数组的最后一个元素，如果数组为空，返回undefined

function pop(arr)//返回数组最后一个元素，并删除该元素，数组长度减一
{
    if (arr.length === 0) {
        console.log("数组为空");
        return;
    }
    let tmp = arr[arr.length - 1];
    arr.length--;
    return tmp;

}

三、shift方法

该方法删除并返回数组的第一个元素，实现时我们只要将第二个元素的值赋给第一个，第三个的值赋给第二个，依次类推，直到最后一个。

function shift(arr)//删除数组的第一个元素，并返回
{
    if (arr.length === 0) {
        console.log("数组为空");
        return;
    }
    let tmp = arr[0];
    for (let i = 0; i < arr.length; i++) {
        arr[i] = arr[i] + 1;
    }
    arr.length--;
    return tmp;

}

四、unshift方法

该方法将任意个数插入到数组的前面，实现方法：将数组从最后一个元素开始依次向后移动参数的个数个位置，即把前面的位置空出来，然后在把参数依次插入到前面

function unshift(arr, ...arg) {
    let len = arg.length;
    for (let j = arr.length - 1; j >= 0; j--) {
        arr[j + len] = arr[j]
    }
    for (let i = 0; i < len; i++) {
        arr[i] = arg[i];
    }
    return arr.length;
}

五、concat方法

该方法接受将任意多个参数合并到原数组后，值得注意的事，如果参数是一个数组，需要将数组展开。

function concat(arr, ...arg) {

    let new_arr = [];
    let i = 0
    for (; i < arr.length; i++) {
        new_arr[i] = arr[i];
    }
    for (let j = 0; j < arg.length; j++) {
        if (arg[j].push) { //判断是不是数组
            for (let k = 0; k < arg[j].length; k++) {
                new_arr[i++] = arg[j][k];
            }
        }
        else {
            new_arr[i++] = arg[j];
        }
    };
    return new_arr;

}

六、slice方法

该方法接受两个参数，第一个参数是截取区间的开始索引，第二个参数是结束索引+1，需要注意的是
1、原生的slice方法当传入的第一个参数不是非数字类型，默认为0。参数为负数则加上数组的长度计算，如果负数的绝对值大于数组的长度，则算作0。
2、第二个参数不是数值时默认为数组长度，如果为负数则加上数组的长度计算。如果负数的绝对值大于数组长度，则算作0.
3、返回值截取的数组

function slice(arr, start, end) {
    start = typeof start === "number" ? start : 0;//判断输入是否为数字，不为数字则代表0
    start = start < 0 ? start + arr.length : start;//如果小于0，则加上数组长度
    start = start < 0 ? 0 : start;               //如果还小于0，代表超过边界，所以算作边界
    end = typeof end === "number" ? end : arr.length;
    end = end < 0 ? end + arr.length : end;
    end = end < 0 ? 0 : end;
    let new_arr = [];
    let j = 0;
    for (let i = start; i < end && i < arr.length; i++) {
        new_arr[j++] = arr[i];
    }
    return new_arr;
}

七、splice方法

该方法接受多个参数，其中第一个参数为开始删除的位置，第二个参数为删除的长度，后面的参数为在删除位置替换的元素，值得注意的是：
1、当第二个参数为0时，该函数可以用于在数组中插入元素
2、原生的slpice方法当传入的第一个参数不是非数字类型，默认为0。参数为负数则加上数组的长度计算，如果负数的绝对值大于数组的长度，则算作0。
3、第二个参数如果为非数值或者负数，都算作0。

function splice(arr, start, num, ...arg) {
    start = typeof start === "number" ? start : 0;//判断输入是否为数字，不为数字则代表0
    start = start < 0 ? start + arr.length : start;//如果小于0，则加上数组长度
    start = start < 0 ? 0 : start;               //如果还小于0，代表超过边界，所以算作边界
    num = (typeof num !== "number" || num < 0) ? 0 : num;
    let len = arg.length;
    let new_arr = [];
    for (let k = 0; k < num; k++) {
        new_arr[k] = arr[k + start];
    }
    let arrlen = arr.length;
    for (let i = start; i < arrlen - num; i++)//删除节点
    {
        arr[i] = arr[i + num];
    }
    arr.length -= num;
    arrlen = arr.length;
    for (let j = arrlen - 1; j > arrlen - 1 - len; j--)//空出替换位置
    {
        arr[j + len] = arr[j];
    }
    for (let j = start; j < start + len; j++)//替换
    {
        arr[j] = arg[j - start];
    }
    return new_arr;
}

八、reverse方法

该方法用于倒置数组，实习起来比较简单，我们将数组第一个数和最后一个交换，第二个和倒数第二个交换，一次类推，值得注意的是，该方法不仅会改变原数组，还会返回原数组。

function reverse(arr)
{
    for(let i=0;i<arr.length/2;i++)
    {
        let tmp=arr[i];
        arr[i]=arr[arr.length-1-i];
        arr[arr.length-1-i]=tmp;
    }
   return arr;
}

九、indexOf方法

该方法接受一个数据，返回该数据在数组中的从左往右第一个索引

function indexOf(arr,value)
{
    for(let i=0;i<arr.length;i++)
    {
        if(arr[i]===value)
        {
            return i;
        }
    }
    return -1;
}

十、lastindexOf方法

该方法接受一个数据，返回该数据在数组中的从右往左第一个索引

function lastdexOf(arr,value)
{
    for(let i=arr.length-1;i>0;i--)
    {
        if(arr[i]===value)
        {
            return i;
        }
    }
    return -1;
}