- Spy decorator
Create a decorator spy(func) that should return a wrapper that saves all calls to function in its calls property.
Every call is saved as an array of arguments.
function work(a, b) {
alert( a + b ); // work is an arbitrary function or method
}
work = spy(work);
work(1, 2); // 3
work(4, 5); // 9
for (let args of work.calls) {
alert( 'call:' + args.join() ); // "call:1,2", "call:4,5"
}
Solution:
function spy(f) {
function wrapper(...args) {
wrapper.calls.push(args);
return f.apply(this, arguments);
}
wrapper.calls = [];
return wrapper;
}
function work(a, b) {
return a + b;
}
work = spy(work);
work(1, 2) // 3
work(2, 4) // 6
for (let args of work.calls) {
alert( 'call:' + args.join() ); // "call:1,2", "call:2,4"
}
- Delaying decorator
Create a decorator delay(f, ms) that delays each call of f by ms milliseconds.
function f(x) {
alert(x);
}
// create wrappers
let f1000 = delay(f, 1000);
let f1500 = delay(f, 1500);
f1000("test"); // shows "test" after 1000ms
f1500("test"); // shows "test" after 1500ms
Solution:
// 不用箭头函数
function delay(func, timeout) {
function wrapper(...args) {
let ctx= this;
setTimeout(function() {
func.apply(ctx, args)
}, timeout)
}
return wrapper;
}
// 使用箭头函数
function delay(f, ms) {
return function() {
setTimeout(() => f.apply(this, arguments), ms)
};
}
- Debounce decorator
The result of debounce(f, ms) decorator should be a wrapper that passes the call to f at maximum once per ms milliseconds.
let f = debounce(alert, 1000);
f(1); // runs immediately
f(2); // ignored
setTimeout( () => f(3), 100); // ignored ( only 100 ms passed )
setTimeout( () => f(4), 1100); // runs
setTimeout( () => f(5), 1500); // ignored (less than 1000 ms from the last run)
Solution:
function debounce(f, ms) {
let isCoolingDown = false;
return function() {
if (isCoolingDown) {
return
}
f.apply(this, arguments);
isCoolingDown = true;
setTimeout(() => isCoolingDown = false, ms);
}
}
- Throttle decorator
Create a “throttling” decorator throttle(f, ms) – that returns a wrapper, passing the call to f at maximum once per ms milliseconds. Those calls that fall into the “cooldown” period, are ignored.
function f(a) {
console.log(a)
};
// f1000 passes calls to f at maximum once per 1000 ms
let f1000 = throttle(f, 1000);
f1000(1); // shows 1
f1000(2); // (throttling, 1000ms not out yet)
f1000(3); // (throttling, 1000ms not out yet)
// when 1000 ms time out...
// ...outputs 3, intermediate value 2 was ignored
Solution:
function throttle(f, ms) {
let isThrottled = false;
let savedArgs, savedThis;
function wrapper() {
if (isThrottled) {
savedArgs = arguments;
savedThis = this;
return;
}
f.apply(this, arguments);
isThrottled = true;
setTimeout(function() {
isThrottled = false;
if (savedArgs) {
wrapper.apply(savedThis, savedArgs);
savedArgs = savedThis = null;
}
}, ms)
}
return wrapper;
}
-
Advanced curry implementation
function sum(a, b, c) {
return a + b + c;
}
let curriedSum = curry(sum);
// still callable normally
alert( curriedSum(1, 2, 3) ); // 6
// get the partial with curried(1) and call it with 2 other arguments
alert( curriedSum(1)(2,3) ); // 6
// full curried form
alert( curriedSum(1)(2)(3) ); // 6
Solution:
function curry(func) {
return function curried(...args) {
if (args.length >= func.length) {
return func.apply(this, args);
} else {
return function(...args2) {
return curried.apply(this, args.concat(args2));
}
}
};
}
- 偏函数在登录中的应用
user 对象被修改了。现在不是两个函数 loginOk/loginFail,现在只有一个函数 user.login(true/false)。
以下代码中,向 askPassword 传入什么参数,使得 user.login(true) 结果是 ok,user.login(fasle) 结果是 fail?
function askPassword(ok, fail) {
let password = prompt("Password?", '');
if (password == "rockstar") ok();
else fail();
}
let user = {
name: 'John',
login(result) {
alert( this.name + (result ? ' logged in' : ' failed to log in') );
}
};
askPassword(?, ?); // ? only change this line
Solution:
(1). askPassword(() => user.login(true), () => user.login(false));
(2). askPassword(user.login.bind(user, true), user.login.bind(user, false));
- fetch 设置超时
function _fetch(fetch_promise, timeout) {
//这是一个可以被reject的promise
const abort_promise = new Promise((resolve, reject) => {
setTimeout(reject, timeout, "abort promise")
});
//这里使用Promise.race,以最快 resolve 或 reject 的结果来传入后续绑定的回调
const abortable_promise = Promise.race([
fetch_promise,
abort_promise
]);
return abortable_promise;
}
//usage:
_fetch(fetch('//a.com/b/c'), 2000)
.then(function(res) {
console.log(res)
}, function(err) {
console.log(err);
});