各种常用js函数实现

1.call/apply

Function.prototype.myCall = function (context, ...args) {
    if (typeof this !== 'function') return;
    var fun = this;
    context._fn = fun; // TODO：确保_fn 键不存在
    var res = context._fn(args);
    return res;
}

// test
function say (...args) {
    return args + this.name
}

var obj = { name: 'rencoo' }

say.myCall(obj, 'hello, ') // "hello, rencoo"

2.bind

• 绑定环境
• 如果以new调用的话,

// var fn = func.bind(obj, ...args);
// fn(...args);
// new fn(...args); // 对 this 来说, new 的优先级高于 bind; 会忽视传入的 context
Function.prototype.myBind = function (context, ...args) {
    if (typeof this !== 'function') return;
    var fun = this;
    return function (...innerArgs) {
        args = args.concat(innerArgs);
        var res = fun.apply(context, args);
        return res;
    }
}

考虑到 new 调用，在返回函数里做一层判断，如果函数是使用使用 new 进行调用的，那么绑定的环境就会失效

var obj = { age: 25 };
function Person(name) {
    this.name = name;
    console.log(this); // (*)
}
Person.prototype.sayHi = function () {
    console.log('hi');
}

var fn = Person.bind(obj, 'Bob');

// 调用后, (*)的打印内容
// 普通调用
fn();
console: { age: 25, name: "Bob" }

// 通过new调用
var p = new fn();
console.log(p); // Person { name: 'Bob' }
console.log(p.sayHi); // f () { console.log('hi') }

改进我们的 myBind

Function.prototype.myBind = function (context, ...args) {
    var fn = this;
    if (typeof fn !== 'function') return;

    var boundFn;
    var binder = function (...innerArgs) {
        args = args.concat(innerArgs);

        // console.log(this instanceof boundFn); // 使用 new 调用时, this 即为构造函数的实例, 判断结果为 true (优先级高于 bind 传入的 context)
        if(this instanceof boundFn) { // new 调用; 不使用bind传入的 context
            var res = fn.apply(this, args);
            if (typeof res === 'object') {
                return res;
            }
            return this;
        } else { // 普通调用
            return fn.apply(context, args);
        }
    }

    boundFn = Function('binder', 'return function (){ return binder.apply(this,arguments); }')(binder);

    if (fn.prototype) {
        var Empty = function Empty() {};
        Empty.prototype = fn.prototype;
        boundFn.prototype = new Empty();
        Empty.prototype = null; 
    }

    return boundFn;
}

// 测试
var obj = { age: 25 };
function Person(name) {
    this.name = name;
    console.log(this); // (*)
}

var fn = Person.myBind(obj, 'Bob');

// 调用后, (*)的打印内容
// 普通调用
fn();
// console: { age: 25, name: "Bob" }

// 通过new调用
new fn();
// console: Person { name: 'Bob' }

常用的装饰器函数 once/throttle/debounce

3.once

Ensure a function is called only once，函数调用一次即失效

function once (fn) {
    var flag = false;
    return function (...args) {
        !flag && fn.apply(this, args);
        flag = true;
    }
}

// more elegant way to write a once function
function once (fn) {
    // closure here; var fn = fn;
    return function (...args) {
        var res = fn && fn.apply(this, args);
        fn = null;
        return res;
    }
}

4.throttle

节流：连续的高频操作，只有最后一次操作后的一段时间后才调用传入的函数(最终的状态最重要)，后一次操作会覆盖前一次操作

应用：实时搜索里的搜索函数、鼠标移动函数中的更新函数、窗口resize里的更新函数

(原因是这些传入的函数可能都是一些耗时耗性能的操作，无法也没必要在每次微小动作上执行)

function throttle (fn, delay) {
    var timer = null;
    return function (...args) {
        // 如果上一次操作的定时器尚未执行，那么取消它并将其替换为一个新的定时器
        clearTimeout(timer);
        timer = setTimeout(() => fn.apply(this, args), delay);
    }
}

5.debounce

防抖：第一次生效，之后一定时间内无论怎么触发都无效

function debounce (fn, wait) {
    var flag = true, timer = null;
    return function (...args) {
        if (flag) {
            flag = false;

            timer = setTimeout(function () {
                flag = true;
                clearTimeout(timer);
            }, wait);

            return fn.apply(this, args);
        }
    }
}

// 另一种写法
function debounce (fn, wait) {
    var timer = null;
    return function (...args) {
        if (!timer) {
            timer = setTimeout(() => { 
                timer = null；
            }, wait);

            return fn.apply(this, args);
        }
    }
}

6.throttle_optimize

升级版的 throttle_optimize 结合了 throttle 与 debounce 的特点

与 throttle 的区别：throttle_optimize 对于用户的第一次操作总是调用传入的函数

与 debounce 的区别：如果被忽略的调用是冷却期间的最后一次，那么它会在延迟结束时执行传入的函数

function throttle_optimize (fn, delay) {
    var flag = true, timer = null;
    return function (...args) {
        if (flag) {
            flag = false;
            fn.apply(this, args);
            args = null;
        }

        clearTimeout(timer);
        timer = setTimeout(() => {
            flag = true;
            if (args) {
                fn.apply(this, args);
            }
        }, delay);
    }
}

7.throttle_optimize

用于动画渲染的 throttle_optimize

对于第一次操作，总是 update；之后的 delay 时间内的最后一次操作总是在 delay 时刻渲染一次；

也就是说装饰器函数 throttle_optimize 会经常调用，但是传入的更新函数，最多每 delay 时间调用一次(也可能不调用，没有任何操作就不会调用)

比如，使用鼠标移动和屏幕坐标原点绘制矩形，鼠标持续移动过程中，每隔delay时间渲染一次矩形，而不是每个移动都绘制，或者说只有最后一次移动结束的一段时间后才绘制(throttle的原理)

function throttle_optimize(func, ms) {

    let isThrottled = false,
        savedArgs,
        savedThis;

    function wrapper() {
        if (isThrottled) {
            savedArgs = arguments;
            savedThis = this;
            return;
        }

        func.apply(this, arguments);
        isThrottled = true;

        setTimeout(function () {
            isThrottled = false;
            if (savedArgs) {
                wrapper.apply(savedThis, savedArgs);
                savedArgs = savedThis = null;
            }
        }, ms);
    }

    return wrapper;
}

8.new

function myNew (Fn, ...args) {
    // 1.生成一个空对象作为this
    // 2.将对象链接到原型上
    let obj = Object.create(Fn.prototype)
    // 3.执行构造函数, 并将obj作为context传入(为实例对象添加属性)
    let res = Fn.apply(obj, args) // 构造函数内的 this 动态改变为 obj
    // 4.return this或者构造函数的执行结果(引用类型)
    return typeof res === 'object' ? res : obj
    // return result instanceof Object ? res : obj
}

// test
function Person (name, age) {
    this.name = name;
    this.age = age;
}

var a = myNew(Person, 'rencoo', 25)
console.log(a) // Person {name: "rencoo", age: 25}
var b = new Person('ge can', 26)
console.log(b) // Person {name: "gecan", age: 26}

Person.prototype.sayHi = function () {
    console.log(this.name)
}

a.sayHi() // rencoo
b.sayHi() // gecan

9.promise

class Promise {
    constructor (executor) {
        // 设置属性 status value resolveCbs rejectCbs
    }
    then (onResolved, onRejected) {

    }
    catch (cb) {
        return this.then(null, cb)
    }
}

promise链式，实现必须上一个异步完成后再去跑下一个任务

// 1.
const template = Promise.resolve();
promises.forEach((p) => {
    template = template.then(p)
})
// 2. 使用 await 

10.deep copy(deepclone)

11.extends

12.singleton

13.pub-sub

14.打印出html里所有标签

15.lazyman

16.快排

17.数组乱序

18.LRU

19.两数之和

20.找出一个集合的所有子集

21.Object.defineProperty

• 实现的关键在那个闭包

22.requestAnimation(京东讲座，react间隙渲染)

/**
 * Provides requestAnimationFrame in a cross browser way.
 * http://paulirish.com/2011/requestanimationframe-for-smart-animating/
 */

if ( !window.requestAnimationFrame ) {

    window.requestAnimationFrame = ( function() {

        return window.webkitRequestAnimationFrame ||
        window.mozRequestAnimationFrame ||
        window.oRequestAnimationFrame ||
        window.msRequestAnimationFrame ||
        function( 
        /* function FrameRequestCallback */ callback, 
        /* DOMElement Element */ element ) {

            window.setTimeout( callback, 1000 / 60 );

        };

    } )();

}

23.手写 Proxy(使用Object.defineProperty将一个对象的属性代理到另一个对象上)

24.webpack

• loader plugin的区别
• tree-shaking 的工作原理(一个模块导出十个方法，但只用到了一个，那么只打包那一个方法)
• code splitting用的是什么插件
• 如何提高 webpack 的构建速度
• 利用 DIIPlugin 预编译资源模块
• 利用 Happypack 加速代码构建

25.jsonp

//通过JQuery Ajax 发起jsonp请求
(注：不是必须通过jq发起请求 , 
     例如:Vue Resource中提供 $.http.jsonp(url, [options]))
$.ajax({
    // 请求方式
    type: "get", 
    // 请求地址
    url: "http://169.254.200.238:8080/jsonp.do", 
    // 标志跨域请求
    dataType: "jsonp",                
    // 跨域函数名的键值，即服务端提取函数名的钥匙（默认为callback）
    jsonp: "callbackparam",   
    // 客户端与服务端约定的函数名称
    jsonpCallback: "jsonpCallback",
    // 请求成功的回调函数，json既为我们想要获得的数据
    success: function(json) {
        console.log(json);
    },
    // 请求失败的回调函数
    error: function(e) {
    alert("error");
    }
});

@RequestMapping({"/jsonp.do"})
public String jsonp(@RequestParam("callbackparam") String callback){
    // callback === "jsonpCallback"
    // return callback + "({\"result\":\"success\"})";
    return  (request.from === jsonp) ? callback(data) : data ;
}

26.实现一个Queue类，要求包含两个函数

task函数：新增一个任务。包含两个参数，等待时间和回调函数

start函数：执行任务队列。将所有任务按队列顺序执行， 执行完一个任务才能执行下一个任务

new Queue()
    .task(1000, () => {
        console.log(1)
    })
    .task(2000, () => {
        console.log(2)
    })
    .task(1000, () => {
        console.log(3)
    })
    .start()

// 链接：https://www.zhihu.com/question/358075914/answer/915814865
const queue = {
  a() {
    setTimeout(() => {
      console.log("a is done");
      this.next();
    }, 1000);
  },
  b() {
    setTimeout(() => {
      console.log("b is done");
      this.next();
    }, 1000);
  },
  c() {
    setTimeout(() => {
      console.log("c is done");
    }, 1000);
  }
};

Object.defineProperty(queue, Symbol.iterator, {
  enumerable: false,
  writable: false,
  configurable: true,
  value() {
    const o = this;
    const ks = Object.keys(o);
    let idx = 0;
    return {
      next() {
        const key = ks[idx++];
        const func = o[key];
        if (typeof func === "function") {
          func.call(this);
        }
        return {
          value: key,
          done: idx > ks.length
        };
      }
    };
  }
});

const qt = queue[Symbol.iterator]();
qt.next();

// a is done
// b is done
// c is done

let queue = new Queue();

queue.push((next) => {
    // do something async
    next();
})

queue.push((next) => {
    // do something async
    Ajax.post('xxx').then(() => next());
});

queue.run()

27.实现一个wait

function wait (time) {
    return new Promise((resolve, rejec) => {
        setTimeout(resolve, time);
    });
}

wait(2000).then(() => {
    console.log('hello1');
    return wait(2000);
}).then(() => {
   console.log('hello2'); 
});

// 使用 await
(async function () {
    var res = await wait(2000);
    // console.log(res); // undefined
    console.log('hello1');
    var res1 = await wait(2000);
    // console.log(res1); // undefined
    console.log('hello2');
})();

28.实现一个jquery事件代理

function on(parent, currentClassName, eventName, cb) {

  parent.addEventListener(eventName, function (evt) {
    var target = evt.target;
    var currentTarget;
    while (target) {
      if (target.tagName === 'BODY') break; // 找到body还没找到(说明点击的位置已经是目标元素的父级了; 不可能找到的)
      if (target.getAttribute('class') === currentClassName) {
        currentTarget = target;
        break;
      } else {
        target = target.parentNode; // 往上找; 从目标元素的子元素触发事件
      }
    }

    if (currentTarget) {
      // 获取 currentTarget 上的数据; 并执行事件回调
      cb.apply(currentTarget);
    }
  });

}