手写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的位置不会变