手写call、apply

https://github.com/mqyqingfeng/Blog/issues/11

Function.prototype.myCall = function (thisTarger) {
    var thisTarget = thisTarget || window
    thisTarger.f = this
    args = []
    for (var i = 1; i < arguments.length; ++i) {
        args.push('arguments[' + i + ']')
    }
    var result = eval('thisTarger.f(' + args + ')')
    delete thisTarger.f
    return result
}

注意传参用'arguments[' + i + ']'的方式，eval之后才能正常调用

Function.prototype.myApply = function (thisTarget, arr) {
    var thisTarget = thisTarget || window
    thisTarget.f = this
    var args = []
    var result

    if (arr) {
        for (var i = 0; i < arguments.length; ++i) {
            args.push('arr[' + i + ']')
        }
        result = eval('thisTarget.f(' + args + ')')
    } else {
        result = thisTarget.f()
    }
    return result
}

注意遍历arr是从0开始的

手写bind

https://github.com/mqyqingfeng/Blog/issues/12

Function.prototype.myBind = function (thisTarget) {
    var that = this
    var args = Array.prototype.slice.apply(arguments, 1)

    var boundF =  function () {
        var bindArgs = Array.prototype.slice.call(arguments)
        return that.apply(this instanceof boundF ? this : thisTarget, args.concat(bindArgs))
    }

    boundF.prototype = Object.create(this)
    return boundF
}

bind的要点比较多，主要是注意一下几个特性的实现：

允许在bind和调用时分别传参
这个特性是通过把bind的传参和调用传参concat实现的
可以使用new执行构造函数
因为new会把this指向一个新对象，所以不能再用thisTarget作为调用时的this

下面具体说一下如何判断使用new的

从手写new我们知道new会返回一个对象，构造函数在调用时满足两个条件：

this指向了这个新对象
构造函数的prototype在新对象的原型链上

this是新对象，那么只要判断构造函数是不是在新对象的原型链上就可以了。所以this instanceof boundF为true也就是boundF在this的原型链上时，是在使用new，这个时候只能用new传入的this来调用。

手写new

https://github.com/mqyqingfeng/Blog/issues/13

function myNew() {
    var obj = Object()
    var constructor = Array.prototype.shift.call(arguments)
    obj.__proto__ = Object.create(constructor.prototype)
    var ret = constructor.apply(obj, arguments)
    return typeof ret === 'object' ? ret : obj
}

var person = myNew(Persen, 'Kevin', '18')

通过这个可以理解new做了什么。new会把一个新对象obj作为构造函数的this引用调用构造函数，同时把新对象的原型指向构造函数的原型。

又根据使用构造函数的不同用两种情况：

构造函数返回一个object，则返回这个对象，注意this在开始已经被指向了obj。
构造函数不返回object，则直接返回obj

这里用了Object.create(constructor.prototype)来用一个中间变量代理构造函数的原型，这样可以保证独立性，寄生继承也用到了这个方法。

手写Ajax

var reqeust = () => {
    if (XMLHttpRequest) {
        return new XMLHttpRequest()
    } else {
        return new ActiveXObject('Microsoft.XMLHTTP')
    }
}

request.onreadystatechange(function () {
    if (request.readyState === 4) {
        if (request.status === 200) {
            console.log('success');
        } else {
            console.log('failed');
        }
    } else {
        console.log('reqeusting...');
    }
})

reqeust.open('GET', 'http://www.baidu.com')
reqeust.send()

readyState：

new XMLHttpRequest(): 0
open(): 1
send(): 2
下载中: 3
完成: 4

手写倒计时

https://juejin.im/post/5bcd89d5e51d4579bb1c5e22

let countdown = 100000; // ms 服务器返回的倒计时剩余时间
let countIndex = 1; // 倒计时任务执行次数
const timeout = 1000; // 触发倒计时任务的时间间隙
const startTime = new Date().getTime();

startCountdown(timeout);

function startCountdown(interval) {
    setTimeout(() => {
        const endTime = new Date().getTime();
        // 偏差值
        const deviation = endTime - (startTime + countIndex * timeout);
        console.log(`${countIndex}: 偏差${deviation}ms`);

        countIndex++;

        // 下一次倒计时
        startCountdown(timeout - deviation);
    }, interval);
}

核心思想：每次生成一个Date()算偏差

修正倒计时的思路：

用起始服务器时间作为时间基准
每次修正
达到误差阈值后重新获取服务器时间计时

手写快排

function quickSort(arr, start, end) {
    var i = start, j = end
    var X = arr[i]
    
    if (i < j){
        while (i < j) {
            while (j > i && arr[j] > X) {
                j--
            }
            if (j > i) {
                arr[i++] = arr[j]
            }
            while (i < j && arr[i] < X) {
                i++
            }
            if (j > i) {
                arr[j--] = arr[i]
            }
        }
        arr[j] = X
        quickSort(arr, start, j - 1)
        quickSort(arr, j + 1, end)
    }
}

要注意的地方：

一定要做i < j的判断才进入循环，不然j会一直变小递归不会退出
要先从j走，因为挖坑挖的是i这一端
如果要用随机参考值优化的话，需要变量来指示一下坑在哪个位置，i和j的位置不会变

前端面试准备