数组各种方法的不完全实现

复习一遍数组的方法 写着玩的 不能完全实现哈

push()

在数组尾部添加一个或多个新元素，并且返回 数组的长度，改变原数组。

arr=[1,2,3,4,5,6,7,8]
function push(arr){
    // 循环从1开始 因为arguments[0] 是数组本身
    for(var i=1;i<arguments.length-1;i++){
        arr[arr.length]=arguments[i]
    }
    return arr.length;
}
console.log(push(arr))
console.log(arr)

pop()

删除数组的尾部元素，并且返回 被删除的元素，改变原数组。

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

unshift()

将一个或者多个新元素添加在数组的最前面，返回 数组的长度，改变原数组。

arr=[1,2,3,4,5,6,7,8]
function unshift(arr){
    var len=arguments.length-1 // 添加几个元素
    for(var i = arr.length-1;i>=0;i--){ // i从旧数组的最后一位开始 向前循环旧数组长度次 
        arr[i+len]=arr[i] // 把所有元素赋值给向后+len的元素位 给添加的元素挪出空间
    }
    for(var j=0;j<len;j++){
        arr[j]=arguments[j+1] // 把添加的元素遍历进旧数组 替换原来的元素
    }
    return arr.length
}
console.log(unshift(arr,10),arr)

shift()

删除数组的第一个元素，并且返回 被删除的元素，改变原数组。

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

concat()

将原数组拼接一个或多个新元素/数组，并返回 拼接后的新数组，不改变原数组

var arr = [1, 2, 3, 4, 5, 6, 7, 8,[9,10]]
function concat(arr) {
    var newArr = [];
    for (var i = 0; i < arr.length; i++) {
        newArr[i] = arr[i]
    }
    for (var j = 1, index = arr.length; j <= arguments.length-1; j++, index++) {
        if (arguments[j].constructor === Array) {
            for (k = 0; k < arguments[j].length; k++, index++) {
                newArr[index] = arguments[j][k]
            }
            index--
        } else newArr[index] = arguments[j]
    }
    return newArr
}
console.log(concat(arr,[4,5,5,5,5]))

join()

使用参数将数组连并接转换为字符串，返回该字符串，不改变原数组

var arr = [1, 2, 3, [4, 5]]
function join(arr, symbol) {
    symbol = symbol || ","
    var str = ""
    for (var i = 0; i < arr.length; i++) {
        str += i === arr.length - 1 ? arr[i] : arr[i] + String(symbol)
    }
    return str;
}
console.log(join(arr, "#"))

splice()

给数组中添加、删除、替换一个或者多个元素，返回被删除元素组成的数组，改变原数组

有些地方没考虑到 感觉跟splice方法不一样 正常的增删改是可以的…

第一种

var arr=[1,2,3,4,5,6,7,8]
function splice(arr, start, count) {
    var a = [];
    start = Number(start);
    count = Number(count);
    if (arguments.length === 1) return a;
    if (arguments.length === 2) count = arr.length - start;
    if (start < 0) start += arr.length;
    // 删除
    for (var i = start, j = 0; i < arr.length; i++, j++) {
        if (j < count) a.push(arr[i]); // 将被删除的push到数组a
        arr[i] = arr[i + count];
    }
    for (var k = 0; k < count; k++) {
        arr.length--; 
    }
    // 向后挪
    // 外层循环控制挪几次
    for (var l = 0; l < arguments.length - 3; l++) {
        // 内层循环控制每个字母向后挪了一位
        for (var m = arr.length - 1; m >= start + l; m--) {
            arr[m + 1] = arr[m];
        }
    }
    // 插入
    for (var n = 3; n < arguments.length; n++) {
        arr[start + n - 3] = arguments[n];
    }
    return a;
}
var arr1 = splice(arr, 2);
console.log(arr1, arr);

第二种

var arr1=[1,2,3,4,5,6,7,8]
var arr2=[1,2,3,4,5,6,7,8]
function splice(arr,start,cut){
    var newArr=[]  //被cut删除的几个元素
    start=Number(start);
    cut=Number(cut);
    if(arguments.length===1||isNaN(start)||isNaN(cut)) return newArr;  //如果只填一个数组 那么返回空数组
    if(arguments.length===2||cut>arr.length-start) cut=arr.length-start; //如果只填数组和开始 那么结束就是到最后
    if(start<0) start=arr.length+start; //如果开始是负数 那么就是倒数第几个
    // 先删除
    for(var i=start,j=0;i<start+cut;i++,j++){
        newArr[j]=arr[i]
    }
    for(var j=start;j<arr.length;j++){
        arr[j]=arr[j+cut]
    }
    arr.length-=cut

    //再给新的挪位置
    var len=arguments.length-3
    for(var k=arr.length-1;k>=start;k--){
        // console.log(k)
        arr[k+len]=arr[k];
    }

    // 再把新的填进去
    for(var m=0;m<len;m++){
        arr[start+m]=arguments[m+3]
    }
    return(newArr)
}
var arr3=splice(arr1,1,"a",9,10)
var arr4=arr2.splice(1,"a",9,10)

console.log(arr1,arr3)
console.log(arr2,arr4)

slice()

从第一个参数开始截取到第二个参数之前，返回截取的新数组，不改变原数组

var arr = [1, 2, 3, 4, 5, 6, 7, 8]
function slice(arr, start, end) {
    start = Number(start);
    end = Number(end);
    if (arguments.length === 0) {
        start = 0;
        end = arr.length;
    }
    if (arguments.length === 1) end = arr.length;
    if (start < 0) start = start + arr.length;
    if (end < 0) end = end + arr.length;

    var newArr = []
    for (i = start, j = 0; i < end; i++, j++) {
        newArr[j] = arr[i + start-1]
    }
    return newArr;
}
console.log(slice(arr, -1, 4))
console.log(arr.slice(-1,4))

reserve()

将数组翻转，返回翻转后的数组，原数组改变。

var arr=[1,2,3,4,5,6,7,8]
function reverse(arr){
    var len = parseInt(arr.length/2)
    var temp;
    for(var i=0;i<len;i++){
        temp=arr[arr.length-1-i]
        arr[arr.length-1-i]=arr[i]
        arr[i]=temp
    }
    return arr
}
console.log(reverse(arr))

sort()

用于对数组的元素进行排序，返回排序好的原数组，原数组改变

sort内部排序比较(wo)复(bu)杂(hui) 就不在这里实现了 常见的三种排序

冒泡排序

// 外层从后向前循环
// 内部从前向后循环到外层变量
// 判断前值是否大于后值 交换

function sort1(arr){
    var len=arr.length;
    while(len>1){
        for(var i=0;i<len;i++){
            if(arr[i]>arr[i+1]){
                var temp=arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=temp;
            }
        }
        len--;
        console.log(arr)
    }
}
var arr = [66,6,3,7,26,154,4]
sort1(arr);

选择排序

先找出最小或者最大的索引值，然后用当前的下标的元素与这个最小的元素交换。

// 遍历数组
// 设置最小的索引值为当前的索引值
// 从当前的下一项开始遍历到数组的尾部
// 判断所有遍历的值中最小的值得索引值
// 交换当前值和最小索引值的元素

function sort2(arr){
    var minIndex;
    for(var i=0;i<arr.length;i++){
        minIndex=i;
        for(var j=i+1;j<arr.length;j++){
            minIndex=arr[minIndex]<arr[j] ? minIndex : j;
        }
        var temp=arr[i];
        arr[i]=arr[minIndex];
        arr[minIndex]=temp;
    }
}
var arr=[1,4,2,2,3,10];
sort2(arr);
console.log(arr);

快排

// 截取并保存数组中间的元素
// 创建两个空数组
// 遍历数组 将小于中间元素的元素放在left 大于中间元素的元素放在right
// 合并left数组递归 + 中间元素 + right数组递归的结果
// 在数组的最开始一定要写 数组的长度小于等于1时 返回该数组

var arr=[1,4,2,2,3,10];
arr=sort3(arr);

function sort3(arr){
    if(arr.length<=1) return arr;
    var left=[];
    var right=[];
    var item=arr.splice(parseInt(arr.length/2),1)[0];
    for(var i=0;i<arr.length;i++){
        if(arr[i]<item) left.push(arr[i]);
        else right.push(arr[i]);
    }
    var arr1=sort3(left).concat(item,sort3(right));
    return arr1;
}

indexOf()