寫在前面

api會用不就行了嗎？不是，有的面試官讓你手撕，
傻了吧，最好的反擊就是學會它然后裝傻，
“之前沒寫過，我試試吧”，然后寫出無懈可擊的答案就可以了

代碼的倉庫地址：陣列的手寫api

改變自身的方法

push()

向陣列的末尾添加一個或更多元素，并回傳新的長度，

Array.prototype.myPush=function(){
    for(let i=0;i<arguments.length;i++){
        this[this.length]=arguments[i]
    }
    return this.length
}
let arr=[1,2,3]
arr.myPush(4)
console.log(arr);

unshift()

向陣列的開頭添加一個或更多元素，并回傳新的長度，

Array.prototype.myUnshift=function(){
    let arrLength=this.length
    let arr=this
    for(let i=arrLength+arguments.length-1;i>=0;i--){
        if(i>arguments.length-1){
            arr[i]=arr[i-arguments.length]
        }else{
            arr[i]=arguments[i]
        }
    }
    return arr.length
}
let arr=[1,2,3]
arr.myUnshift(4)
console.log(arr);

pop()

洗掉陣列的最后一個元素并回傳洗掉的元素，

Array.prototype.myPop=function(){
    let arr=this
    if(arr.length===0) return undefined
    let ans=arr[this.length-1]
    this.length=this.length-1
    return ans
}
let arr=[1,2,3]
let res=arr.myPop()
console.log(arr,res);

shift()

洗掉并回傳陣列的第一個元素，

Array.prototype.myShift=function(){
    let arr=this
    if(arr.length===0) return undefined
    let ans=arr[0]
    for(let i=1;i<arr.length;i++){
        arr[i-1]=arr[i]
    }
    this.length=this.length-1
    return ans
}
let arr=[1,2,3]
let ans=arr.myShift()
console.log(arr,ans);

reverse()

反轉陣列的元素順序，

Array.prototype.myReverse=function(){
    let arr=this
    let arrLength=arr.length
    let copyArr=Array.from(arr)
    for(let i=0;i<arrLength;i++){
        arr[arrLength-i-1]=copyArr[i]
    }
    return arr
}
let arr=[1,2,3]
let ans=arr.myReverse()
console.log(ans);

copyWithin()

從陣列的指定位置拷貝元素到陣列的另一個指定位置中，

Array.prototype.myCopyWithin=function(target,start,end=this.length){
    let arr=this
    for(let i=start;i<end;i++){
        arr[target]=arr[i]
        target++;
    }
    return arr
}
let arr=['a','b','c','d','e']
arr.copyWithin(0,3,4)
console.log(arr);
arr=['a','b','c','d','e']
arr.myCopyWithin(0,3,4)
console.log(arr);
arr.myCopyWithin(1,3)
console.log(arr);

fill()

使用一個固定值來填充陣列，

Array.prototype.myFill=function(value,start=0,end=this.length){
    let arr=this
    for(let i=start;i<end;i++){
        arr[i]=value
    }
    return arr
}
let arr=[1,2,3,4]
arr.myFill(0,2,4)
console.log(arr);
arr.myFill(5,1)
console.log(arr);
arr.myFill(6)
console.log(arr);

不改變自身的方法

concat()

連接兩個或更多的陣列，并回傳結果，

Array.prototype.myConcat=function(){
    let arr=this
    for(let i=0;i<arguments.length;i++){
        for(let j=0;j<arguments[i].length;j++){
            arr[this.length]=arguments[i][j]
        }
    }
    return arr
}
let arr=['123','456']
let arr1=['1','2','3']
let arr2=['4','5','6']
let res=arr.myConcat(arr1,arr2)
console.log(arr);

slice()

選取陣列的一部分，并回傳一個新陣列，

Array.prototype.mySlice=function(start,end=this.length){
    let arr=this
    let res=[]
    if(start<0){
        for(let i=start+end;i<end;i++){
            res.push(arr[i])
        }
    }else{
        for(let i=start;i<end;i++){
            res.push(arr[i])
        }
    }
    return res
}

let arr=[1,2,3,4,5,6]
let res=arr.mySlice(-4)
console.log(arr,res);
res=arr.mySlice(1)
console.log(res);

indexOf()

搜索陣列中的元素，并回傳它所在的位置，

Array.prototype.myIndexOf=function(num){
    let arr=this
    for(let i=0;i<arr.length;i++){
        if(arr[i]===num){
            return i
        }
    }
    return -1
}
let arr=[1,2,3,4,5,6]
console.log(arr.myIndexOf(5));

lastIndexOf()

搜索陣列中的元素，并回傳它最后出現的位置，

Array.prototype.myLastIndexOf=function(num){
    let arr=this
    for(let i=arr.length-1;i>=0;i--){
        if(arr[i]===num) return i
    }
    return -1
}

let arr=[1,2,3,4,4,4]
console.log(arr.myLastIndexOf(4));

join()

把陣列的所有元素放入一個字串，

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

let arr=[1,2,3,4,5,6]
let res=arr.myJoin('-')
console.log(arr,res);

toString()

把陣列轉換為字串，并回傳結果，

Array.prototype.myToString=function(separator=','){
    let arr=this
    let str=''
    for(let i=0;i<arr.length;i++){
        str+=arr[i]
        if(i!=arr.length-1){
            str+=separator
        }
    }
    return str
}
let arr=[1,2,3,4,5,6]
let arr1=[1,2,'a','b']
res=arr1.myToString()
console.log(arr1,res);

陣列的遍歷方法

forEach()

陣列每個元素都執行一次回呼函式，

Array.prototype.myForEach=function(fn,thisArg){
    let arr=this
    for(let i=0;i<arr.length;i++){
        fn.call(thisArg,arr[i])
    }
}

let obj={
    num:10
}
let arr=[1,2,3,4,5,6]
arr.myForEach(function(value,index,arr){
    console.log(value+this.num);
},obj)
console.log(arr);

map()

通過指定函式處理陣列的每個元素，并回傳處理后的陣列，

Array.prototype.myMap=function(fn,thisArg){
    if(Object.prototype.toString.call(fn).slice(8,-1)!=="Function"){
        throw new error("The first argument must be a function!")
    }
    let result=[]
    let currentArr=this
    for(let i=0;i<currentArr.length;i++){
        result[i]=fn.call(thisArg,currentArr[i],i,currentArr)
    }
    return result
}
// console.log(Object.prototype.toString.call(123).slice(8,-1));

arr=[1,2,3,4,5,6]
console.log(arr.map((item,index,arr)=>{
    return item*2
}));
console.log(arr.myMap((item,index,arr)=>{
    return item+1
}));

filter()

檢測數值元素，并回傳符合條件所有元素的陣列，

Array.prototype.myFilter=function(fn){
    if(Object.prototype.toString.call(fn).slice(8,-1)!=="Function"){
        throw new error("ths first argument must be Function!")
    }
    let arr=this
    let res=[]
    for(let i=0;i<arr.length;i++){
        if(fn(arr[i],i,arr)){
            res.push(arr[i])
        }
    }
    return res
}
let arr=[1,2,3,4,5,6,7,8,9]
let res=arr.myFilter((value,index,arr)=>{
    return value>4
})
console.log(arr,res);

every()

檢測數值元素的每個元素是否都符合條件，

Array.prototype.myEvery=function(fn){
    let arr=this
    let count=0
    for(let i=0;i<arr.length;i++){
        if(fn(arr[i])){
            count++
        }
    }
    if(count===arr.length){
        return true
    }else{
        return false
    }
}

let arr=[1,2,3,4,5,6,7,8]
let res=arr.myEvery(value=>{
    return value>4
})
console.log(arr,res);
res=arr.myEvery(value=>{
    return value>0
})
console.log(res);

some()

檢測陣列元素中是否有元素符合指定條件，

Array.prototype.mySome=function(fn){
    let arr=this
    for(let i=0;i<arr.length;i++){
        if(fn(arr[i])) return true
    }
    return false
}

let arr=[1,2,3,4,5,6]
let res=arr.mySome(value=>{
    return value>4
})
console.log(arr,res);

reduce()

將陣列元素計算為一個值（從左到右），

Array.prototype.myReduce=function(fn,initValue){
    let arr=this
    let currentIndex=arguments.length===1?1:0
    let currValue=arguments.length===1?arr[0]:initValue
    for(let i=currentIndex;i<arr.length;i++){
        currValue=fn(currValue,arr[i])
    }
    return currValue
}
let arr=[1,2,3,4,5]
let result=arr.myReduce((preval,nextval)=>{
    return preval+nextval
},1)
console.log(result);

entries()

從陣列 fruit 創建一個可迭代物件， 該物件包含了陣列的鍵值對：

Array.prototype.myEntries=function(){
    let ans=[]
    for(let i=0;i<this.length;i++){
        ans[i]=[]
        ans[i].push(i)
        ans[i].push(this[i])
    }
    return ans
}
let arr=['12313','12','545']
console.log(arr.myEntries());