手写数组方法（一）_手写数组中的方法-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_66130560/article/details/142496861

pop

push

pop

pop：删除数组的最后一位，返回被删除的数据，改变原数组

Array.prototype.myPop=function(){
    if(!this.length){
        return undefined
    }
    // 直接数组长度减一，数组就删除了最后一位  
    const len=this.length
    const data=this[len-1]
    this.length=len-1
    return data
}

push

push:向数组的末尾添加一个或多个元素，返回新数组的长度，改变原数组

Array.prototype.myPush=function(...args){
      if(args.length==0){
           return this.length
       }
      // 数组长度自动增加
      for(const i of args){
           this[this.length]=i
      }
      return this.length
}

shift

shift:移除数组的第一项，返回被删除的数据，改变原数组

Array.prototype.myShift=function(){
    if(this.length===0){
         return undefined
    }
    const data=this[0]
    const len=this.length-1
    for(let i=1;i<=len;i++){
          this[i-1]=this[i]
    }
    this.length=len
    return data
}

注意：下面这种写法存在数组越界问题

for(let i=0;i<this.length;i++){
  this[i]=this[i+1] //存在数组越界问题：在循环中，当 i 等于 this.length - 1 时，this[i+1] 会是 undefined，并且尝试将其赋值给 this[i] 会导致最后一个元素被设置为 undefined
}
this.length=this.length-1

unshift

unshift:向数组的开头添加一个或多个元素，返回新数组长度，改变原数组

 Array.prototype.myUnshift=function(...args){
      if(args.length==0){
          return this.length
      }
      // const arr=[...args,...this]
      // for(let i=0;i<arr.length;i++){
      //     this[i]=arr[i]
      // }

      // 一个更高效的实现可以直接在原数组上操作，避免创建不必要的中间数组
      const num=args.length
      for(let i=this.length-1;i>=0;i--){
           this[i+num]=this[i]
      }
      for(let j=0;j<num;j++){
           this[j]=args[j]
      }
      return this.length
}

reverse

reverse：反转数组中的元素，返回反转后数组，改变原数组

Array.prototype.myReverse=function(){
    // 用下面这个方法，对于大数据量的数组，耗内存
    // const that=[...this]
    // for(let i=0;i<that.length;i++){
    //     this[i]=that[that.length-1-i]
    // }

     let left=0
     let right=this.length-1
     while(left<right){
        let tem=this[left]
        this[left]=this[right]
        this[right]=tem
        left++
        right--
     }
     return this
}

concat

concat:用于合并两个或多个数组，不改变原数组，返回一个新数组。如果没有参数，则返回原数组的一个浅拷贝数组

Array.prototype.myConcat=function(...args){
      let arr=[...this]
      for(let i=0;i<args.length;i++){
            if(Array.isArray(args[i])){
                 arr.push(...args[i])
            }else{
                 arr.push(args[i])
            }
      }
            
      return arr
}

join

join:将一个数组的所有元素连接成一个字符串并返回这个字符串，用逗号或者指定的分隔符分隔开来。如果数组只有一个元素，那么将返回该元素而不适用分隔符

Array.prototype.myJoin=function(separator=','){
    let str=''
    for(let i=0;i<this.length;i++){ 
          if(i==this.length-1){
               str+=this[i]
               break
           }
           str+=this[i]+separator
    }
    return str
}

slice

slice:返回一个新数组，不改变原数组，浅拷贝。截取从start到end之间的数据，包括start,不包括end

Array.prototype.mySlice=function(start=0,end){
       const len=this.length
       if(start<0){
           start=Math.max(start+len,0)
       }else if(start>len){
           start=len
       }

       if(end<0){
           end=Math.max(end+len,0)
       }else if(end>len||end==undefined){
           end=len
       }
       let arr=[]
       for(let i=start;i<end;i++){
           arr[arr.length]=this[i]
       }
       return arr
}

更新中。。。。

如果本文对你有帮助，希望能得到你的点赞或收藏或关注，这是对我最好的鼓励；

如你有问题或疑惑，欢迎在评论区写下，必将努力解答；

如本文有误区，希望你不吝赐教，让我们共勉！