函数

1. attempt：捕获函数运行异常

该代码段执行一个函数，返回结果或捕获的错误对象。

1. onst attempt = (fn, ...args) => {
2. try {
3. return fn(...args);
4. } catch (e) {
5. return e instanceof Error ? e : new Error(e);
6. }
7. };
8. var elements = attempt(function(selector) {
9. return document.querySelectorAll(selector);
10. }, '>_>');
11. if (elements instanceof Error) elements = []; // elements = []
12. 复制代码

2. defer：推迟执行

此代码段延迟了函数的执行，直到清除了当前调用堆栈。

1. const defer = (fn, ...args) => setTimeout(fn, 1, ...args);
2. 
3. defer(console.log, 'a'), console.log('b'); // logs 'b' then 'a'
4. 复制代码

3. runPromisesInSeries：运行多个Promises

1. const runPromisesInSeries = ps => ps.reduce((p, next) => p.then(next), Promise.resolve());
2. const delay = d => new Promise(r => setTimeout(r, d));
3. 
4. runPromisesInSeries([() => delay(1000), () => delay(2000)]);
5. //依次执行每个Promises ，总共需要3秒钟才能完成
6. 复制代码

4. timeTaken：计算函数执行时间

1. 
2. const timeTaken = callback => {
3. console.time('timeTaken');
4. const r = callback();
5. console.timeEnd('timeTaken');
6. return r;
7. };
8. 
9. timeTaken(() => Math.pow(2, 10)); // 1024, (logged): timeTaken: 0.02099609375ms
10. 复制代码

5. createEventHub：简单的发布/订阅模式

创建一个发布/订阅（发布-订阅）事件集线，有emit，on和off方法。

1. 使用Object.create(null)创建一个空的hub对象。
2. emit，根据event参数解析处理程序数组，然后.forEach()通过传入数据作为参数来运行每个处理程序。
3. on，为事件创建一个数组（若不存在则为空数组），然后.push()将处理程序添加到该数组。
4. off，用.findIndex()在事件数组中查找处理程序的索引，并使用.splice()删除。 ```
5. const createEventHub = () => ({
6. hub: Object.create(null),
7. emit(event, data) {
8. (this.hub[event] || []).forEach(handler => handler(data));
9. },
10. on(event, handler) {
11. if (!this.hub[event]) this.hub[event] = [];
12. this.hub[event].push(handler);
13. },
14. off(event, handler) {
15. const i = (this.hub[event] || []).findIndex(h => h === handler);
16. if (i > -1) this.hub[event].splice(i, 1);
17. if (this.hub[event].length === 0) delete this.hub[event];
18. }
19. });
20. 复制代码

    用法：

21. const handler = data => console.log(data);
22. const hub = createEventHub();
23. let increment = 0;
25. // 订阅，监听不同事件
26. hub.on(‘message’, handler);
27. hub.on(‘message’, () => console.log(‘Message event fired’));
28. hub.on(‘increment’, () => increment++);
30. // 发布：发出事件以调用所有订阅给它们的处理程序，并将数据作为参数传递给它们
31. hub.emit(‘message’, ‘hello world’); // 打印 ‘hello world’ 和 ‘Message event fired’
32. hub.emit(‘message’, { hello: ‘world’ }); // 打印 对象 和 ‘Message event fired’
33. hub.emit(‘increment’); // increment = 1
35. // 停止订阅
36. hub.off(‘message’, handler);
37. 复制代码

    <a name="UW0Em"></a>
    ### 6. `memoize`：缓存函数
    通过实例化一个`Map`对象来创建一个空的缓存。<br />通过检查输入值的函数输出是否已缓存，返回存储一个参数的函数，该参数将被提供给已记忆的函数；如果没有，则存储并返回它。

38. const memoize = fn => {
39. const cache = new Map();
40. const cached = function(val) {
41. return cache.has(val) ? cache.get(val) : cache.set(val, fn.call(this, val)) && cache.get(val);
42. };
43. cached.cache = cache;
44. return cached;
45. };
46. 复制代码

    **Ps: 这个版本可能不是很清晰，还有Vue源码版的：**

47. /**
48. • Create a cached version of a pure function.
49. */
50. export function cached (fn: F): F {
51. const cache = Object.create(null)
52. return (function cachedFn (str: string) {
53. const hit = cache[str]
54. return hit || (cache[str] = fn(str))
55. }: any)
56. }

57. 复制代码

    <a name="0AmOK"></a>
    ### 7. `once`：只调用一次的函数
    ```javascript
    const once = fn => {
    let called = false
    return function () {
     if (!called) {
       called = true
       fn.apply(this, arguments)
        }
      }    
    };

    8. flattenObject：以键的路径扁平化对象

    使用递归。

58. 利用Object.keys(obj)联合Array.prototype.reduce()，以每片叶子节点转换为扁平的路径节点。

59. 如果键的值是一个对象，则函数使用调用适当的自身prefix以创建路径Object.assign()。
60. 否则，它将适当的前缀键值对添加到累加器对象。
61. prefix除非您希望每个键都有一个前缀，否则应始终省略第二个参数。 ```javascript const flattenObject = (obj, prefix = ‘’) => Object.keys(obj).reduce((acc, k) => { const pre = prefix.length ? prefix + ‘.’ : ‘’; if (typeof obj[k] === ‘object’) Object.assign(acc, flattenObject(obj[k], pre + k)); else acc[pre + k] = obj[k]; return acc; }, {}); flattenObject({ a: { b: { c: 1 } }, d: 1 }); // { ‘a.b.c’: 1, d: 1 }

```