一些面试经常考的js功能函数笔记（不一定对）

//防抖 经过一定的延迟执行一次 接受一个函数 返回防抖的函数
function debounce(fn,delay){

    var _args = Array.prototype.slice.call(arguments,2) //获取参入的参数
    var timer = null;
    return function(){
        var that = this //保存this对象 因为有些事件触发需要保存当前的对象
        var _secondArgs = [].concat(Array.prototype.slice.call(arguments),_args) //获取参入的参数
        clearTimeout(timer);
        timer = setTimeout(function(){
            fn.apply(that,_secondArgs)
        },delay)    
    }
}

var test = document.getElementById('test')
var hello = '456'
test.name = '123'
var hh = throttle(function(){
    console.log(this.name,hello)
},2000,hello)

test.onclick = hh


//节流
function throttle(fn,delay){
    var _args = Array.prototype.slice.call(arguments,2) //获取参入的参数
    var timer = null;
    return function(){
        var that = this //保存this对象 因为有些事件触发需要保存当前的对象
        var _secondArgs = [].concat(Array.prototype.slice.call(arguments),_args) //获取参入的参数
        if(!timer){
            timer = setTimeout(function(){
                fn.apply(that,_secondArgs);
                timer = null
            },delay)    
        }
        
    }
}

//var a = b.bind()
//bind的模拟实现

Function.prototype._bind = function(context){
　　var that = this
　　var _args = Array.prototype.slice.call(arguments,1);

　　var _fun=function(){
　　　　var args = _args.concat(Array.prototype.slice.call(arguments));
　　　　if(this instanceof _fun){
　　　　　　return that.apply(this,args)
　　　　}else{
　　　　　　return that.apply(context,args)
　　　　}
　　}

　　var _fonp = function(){};
　　_fonp.prototype = this.prototype
　　_fun.prototype = new _fonp()
　　return _fun

}

//数组扁平化
function flattern(array){
    var _returnArray = []
    array.forEach(function(ele){
        if(Array.isArray(ele)){
            //还是数组的话继续递归
            _returnArray = _returnArray.concat(flattern(ele))
        }else{
            _returnArray.push(ele)
        }
    })

    return _returnArray
    
}

console.log(flattern([1,2,[3,4,[5,6,7]],[8,9,[10,[11,12[13,14]]]]]))

//深拷贝
function deepCopy(object){
    var isObject = function(target){
        return (typeof(target) ==='object' && object !== null);
    }
    
    var _returnObject = Array.isArray(object) ? [] : {}
    
    
    if(!isObject(object)){
        throw new Error('深拷贝对象必须为数组或者对象哦');
    }
    //遍历对象
    for(var key in object){
        if(object.hasOwnProperty(key)){
            //如果key值是null的话 直接进行赋值 如果不做这一步的话会在上面直接返回一个false值
            if(object[key] === null){
                _returnObject[key] = object[key]
            }else if(isObject( object[key] )){
                                //递归调用自身
                _returnObject[key] = deepCopy(object[key])
            }
            else{
                _returnObject[key] = object[key]
            }
        }
    }
    return _returnObject
}
var test = [null,2,[3,undefined,5,[1]],{key:null,value:2},'123',function(){console.log(2)},false]
var testObject = deepCopy(test)
test[1] = 'test'
test[2][0] = 'test'
test[2][3].push('test')
test[3].key = 'test'
test[5] = '1111'
console.log(testObject);

//函数柯丽化 用闭包把参数保存起来，当参数的数量足够执行函数了，就开始执行函数
function curry(fn,setArray){
    var length = fn.length //获取需要传参的长度
    var setArray = setArray || [] //已经设置了的传参
    
    return function(){
        var args = setArray.concat(Array.prototype.slice.call(arguments)); //获取额外传入的参数
        //如果传参的长度小于真实需要参数的长度 那么就返回 重新返回一个函数
        if(args.length <length){
            return curry.call(this,fn,args)
        }else{
            //大于的话就执行函数
            return fn.apply(this,args)
        }
    }
}

var _testCurry = curry(function(a,b,c,d,f,g){
    console.log(a,b,c,d,f,g)
})

_testCurry(1)(1)(2)(3,4,5,6,7);

//实现一个eventEmitter
class eventEmitter {
    constructor(maxLength = 10){
        this._events = Object.create(null);
        this.maxLength = maxLength
    }

    addListners(type,cb){
        //判断是否已经添加了这个方法了 如若添加了的话必须放进去一个数组中 超过的话直接报错
        if(this._events[type] && this._events[type].length === this.maxLength) throw new Error(`超出${this.maxLength}个监听事件限制啦`);
        this._events[type] = this._events[type] ? [...this._events[type],cb] : [cb]

    }
    emitEvents(type,...args){
        if(this._events[type]){
            this._events[type].forEach((listner) =>{
                listner.apply(this,args)
            })
        }
    }
    //监听一次 只触发一次就要删除
    once(type,cb){
        //先绑定 在addListners的基础上调用之后就删除 重新声明一个函数
        function onceListners(...args){
            cb && cb.apply(this,args);
            //调用完成之后删除这个监听器
            this.removeListner(type,onceListners)

        }
        this.addListners(type,onceListners)
    }
    removeListner(type,cb){
        const removeTarget = this._events[type]
        if(removeTarget){
            //如果没传cb 说明全部删除
            if(!cb){
                this._events[type] = []
            }
            this._events[type] = this._events[type].reduce((prev,cur) => {
                if(cur !==cb){
                    prev.push(cur)
                }
                
                return prev
            },[]);

        }
    }
    //设置最大监听数
    setMaxListners(n = 10){
        this.maxmaxLength = n
    }
    static getInstance(maxLength = 10){
        if(eventEmitter._instance){
            return eventEmitter._instance
        }else{
            eventEmitter._instance = new eventEmitter(maxLength);
            return eventEmitter._instance
        }
    }
}
const _fn = function(data){
    console.log('once'+data)
}
const _test = eventEmitter.getInstance(3);
_test.addListners('hhh',function(data){
    console.log('hhh111'+data,this._events)
})
_test.once('hhh1',_fn)
_test.addListners('hhh',(data)=>{
    console.log('hhh222'+data)
})
_test.emitEvents('hhh',123);

_test.emitEvents('hhh1',123);

lazyMan

//lazyman

class LazyMan{
    constructor(name){
        this.name = name;
        this.task = [];
        
        let consoleName = () =>{
            console.log(`i am lazyName ${this.name}`)
            this.next()
        }
        this.task.push(consoleName);
        setTimeout(() =>{
            console.log('start');
            this.next();
        },0)
        
    }
    sleep(time){
    
        let _sleep = () =>{
           
            setTimeout(() =>{
                console.log(`${this.name} sleep ${time} alearady`);
                this.next()
             },time*1000);
          }

        this.task.push(_sleep);
        return this
    }
    eat(data){
        let _eat = () =>{
            console.log(`${this.name}eat${data}`);
            this.next()
        }
        this.task.push(_eat);
        return this
    }
    next(){
        //每次执行完一个任务获取下一个任务 并且去除一开始的任务
        let nextTask = this.task.shift();
    
        //console.log(nextTask)
        nextTask && nextTask()
    }
}

let man =  new LazyMan('wuhr')
man.sleep(0.5).eat('fan').sleep(4).eat('zhopu');