前端手写方法代码

//实现bind()

Function.prototype.myBind=function(context){

    if(typeof this !=='function'){

        throw new Error('ERROR');

    }

    var self=this;

    var args=Array.prototype.slice.call(arguments,1);

    return function(){

        var bindArgs=Array.prototype.slice.call(arguments);

        return self.apply(context,args.concat(bindArgs));

    }

}

//实现apply()

Function.prototype.myApply=function(context,args){

    //如果没有指明，就默认全局，但在严格模式下是undefined

    context=context?Object(context):window;

    context.fn=this;

    let res;

    if(!args){

        res=context.fn();

    }else{

        res=context.fn(...args);

    }

    //清除可删除的内存占用

    delete context.fn;

    return res;

}

//实现call()

Function.prototype.myCall=function(context){

    context=context?Object(context):window;

    context.fn=this;

    //由于call(this,arg1,arg2,...,args)

    let args=[...arguments].slice(1);

    let res=context.fn(...args);

    delete context.fn;

    return res;

}

//实现instanceof()

function myInstanceof(left,right){

    let rightPrototype=right.prototype;

    left = left._proto_;

    while(true){

        if(!left) return false;

        if(left === rightPrototype){

            return true;

        }

        left=left._proto_;

    }

}

//实现new()

function myNew(fn,...args){

    let obj={};

    obj._proto_=fn.prototype;

    let res=fn.apply(obj,args);

    return res instanceof Object? res : obj;

}

//实现jsonp

function myJsonp(url,data,callback){

    let params=[];

    for(let i in data){

        params.push(i + "=" + data[i]);

    }

    var newScript=document.createElement('script');

    newScript.src=url+'?'+params.join('&');

    document.body.appendChild(newScript);

}

//实现promise

const PENDING='PENDING';

const REJECTED='rejected';

const RESOLVED='resolved';

const myPromise=function(fn){

    //status用于存储状态码

    this.status=PENDING;

    this.data=null;

    //分别存储then方法传递进来的接收或拒绝数据

    this.onRejectedList=[];

    this.onResolvedList=[];

    let resolved = (value)=>{

        //对于每个promise函数来说，只执行一次reolved

        if(this.status !==PENDING){

            return;

        }

        this.status=RESOLVED;

        this.data=value;

        if(this.onResolvedList.length>0){

            setTimeout(()=>{

                this.onResolvedList.forEach(onResolved=>{

                    onResolved(value);

                })

            },0)

        }

    }

    let rejected =(reason)=>{

        if(this.status!== PENDING){

            return;

        }

        this.status=REJECTED;

        this.data=reason;

        if(this.onRejectedList.length>0){

            setTimeout(()=>{

                this.onRejectedList.forEach(onRejected=>{

                    onRejected(reason);

                })

            },0)

        }

    }

    try{

        fn(resolved,rejected);

    }catch(error){

        this.reject(error);

    }

}

//实现深拷贝

function myDeepclone(obj){

    let copy=obj instanceof Array ? []:{};

    for(let key in obj){

        if(obj.hasOwnProperty(key)){

            copy[key]= typeof obj[key]==='object' ? myDeepclone(obj[key]):obj[key];

        }

    }

    return copy;

}

//实现函数节流-时间戳

const throttle=function(fn,wait){

    let pre= +new Date();

    return function(...args){

        let now = +new Date();

        if(now-pre>wait){

            pre=now;

            fn.apply(this,args);

           

        }

    }

}

//实现函数节流-定时器

const throttle2=function(fn,wait){

    let timeout=null;

    return function(...args){

        if(!timeout){

            timeout=setTimeout(()=>{

                timeout=null;

                fn.apply(this,args);

            },wait)

        }

    }

}

//实现函数防抖

const debounce=function(fn,wait){

    let timer=null;

    return function(...args){

        if(timer) clearTimeout(timer);

        timer=setTimeout(()=>{

            fn.apply(this.args);

        },wait)

    }

}

//实现函数柯里化

function myCurry(fn,length){

    length=length||fn.length;

    return function(...args){

        return args.length>=length ? fn.apply(this,args) : myCurry(fn.bind(this,...args),length-args.length);

    }

}

//实现数组扁平化

let myFlatten=function(arr){

    let res=[];

    for(let i=0;i<arr.length;i++){

        if(Array.isArray(arr[i])){

            res=res.concat(myFlatten(arr[i]));

        }else{

            res.push(arr[i]);

        }

    }

    return res;

}

//实现数组去重

function myUnique(arr){

    for(let i=0;i<arr.length-1;i++){

        for(let j=i+1;j<arr.length;j++){

            if(arr[i]===arr[j]){

                arr.splice(j,1);

                j--;

            }

        }

    }

    return arr;

}

function myUnique2(arr){

   for(let i=0;i<arr.length;i++){

       if(arr.indexOf(arr[i])!==i){

           arr.splice(i,1);

           i--;

       }

   }

   return arr;

}

//实现快速排序

function myQuickSort(arr){

    if(arr.length<=1) return arr;

    let pivotIndex=arr.length>>1;

    let pivot=arr.splice(pivotIndex,1)[0];

    let left=[];

    let right=[];

    for(let i=0;i<arr.length;i++){

        if(arr[i]<=pivot){

            left.push(arr[i]);

        }else{

            right.push(arr[i]);

        }

    }

    return myQuickSort(left).concat(pivot,myQuickSort(right));

}

//实现归并排序

function myMerge(left,right){

    let res=[];

    while(left.length>0 && right.length>0){

        if(left[0]<right[0]){

            res.push(left.shift());

        }else{

            res.push(right.shift());

        }

        return res.concat(left).concat(right);

    }

}

function myMergeSort(arr){

    if(arr.length<=1) return arr;

    let mid=Math.floor(arr.length/2);

    let left=arr.slice(0,mid);

    let right=arr.slice(mid);

    return myMerge(myMergeSort(left),myMergeSort(right));

}

//实现最长递增子序列

function myLIS(array){

    if(array.length===0) return 0;

    let arr=new Array(array.length).fill(1);

    for(let i=1;i<array.length;i++){

        for(let j=0;j<i;j++){

            if(array[i]>array[j]){

                arr[i]=Math.max(arr[i],arr[j]+1);

            }

        }

    }

    let ans=1;

    for(let k=0;k<arr.length;k++){

        ans=Math.max(ans,arr[k]);

    }

    return ans;

}