教你优雅的使用迭代器模式以及案例复盘

              眼看新的一年又来了，为了提高程序员的幸福指数, 我觉得设计模式还是非常有必要好好复盘一下的. 笔者基于工作中的总结和提炼，为了提高团队代码质量和可维护性，特意写了几篇设计模式的文章，供大家参考和学习。

你将学到

• 迭代器模式的含义
• 实现一个数组迭代器
• 实现一个对象迭代器
• 实现路径查找/赋值迭代器
• 如何用迭代器的思想解决分支循环嵌套问题
• 实现一个图片播放器

正文

1.迭代器的含义

• 迭代器模式主要的思想就是在不暴露对象内部结构的同时可以按照一定顺序访问对象内部的元素。

其实javascript中的很多方法都运用了迭代器的思想，比如数组的forEach，every，find，some，map，entries等等，这些操作极大的简化了我们的逻辑操作，接下来我们就来看看它的具体应用吧。

2.实现一个数组迭代器

我们都知道javascript中数组的forEach方法，那么不用这个方法，我们能自己实现一个吗?

1. // 数组迭代器 
2. let eachArr = function(arr, fn) { 
3.     let i = 0, 
4.     len = arr.length; 
5.     for(; i < len; i++) { 
6.         if(fn.call(arr[i], i, arr[i]) === false) { 
7.             break; 
8.         } 
9.     } 
10. } 
11.  
12. // 使用 
13. eachArr([1,2,3,4], (index, value) => { console.log(index, value) }) 

3.实现一个对象迭代器

对象迭代器和数组迭代器类似， 只是传参不同，如下：

1. // 对象迭代器 
2. let eachObj = function(obj, fn) { 
3.     for(let key in obj) { 
4.         if(fn.call(obj[key], key, obj[key]) === false) { 
5.             break; 
6.         } 
7.     } 
8. } 
9.  
10. // 使用 
11. eachObj({a: 11, b: 12}, (key, value) => { console.log(key, value) }) 

4.实现路径查找/赋值迭代器

有时候我们操作对象的某些属性时，我们不知道服务器端是否将该属性或者该属性的上级属性正确的返回给我们，这个时候我们直接通过点语法或者[]语法直接访问会导致代码报错，因此需要我们每一层操作都要做安全校验，这样会产生大量臃肿代码，比如：

1. let obj = {}; 
2. // 获取 obj.num.titNum 
3. let titNum = obj.num.titNum;    // 报错 
4. let titNum = obj && obj.num && obj.num.titNum;   // 正确 

我们通过迭代器可以极大的减少这种校验，实现更健壮的代码模式：

1. let findObjAttr = function(obj, key){ 
2.     if(!obj || !key) { 
3.         return undefined 
4.     } 
5.     let result = obj; 
6.     key = key.split('.'); 
7.     for(let i =0; len = key.length; i< len; i++) { 
8.         if(result[key[i]] !== undefined) { 
9.             result = result[key[i]] 
10.         }else { 
11.             return undefined 
12.         } 
13.     } 
14.     return result 
15. } 
16. // 使用 
17. let a = { b: { c: { d: 1 } } }; 
18. findObjAttr(a, 'a.b.c.d')     // 1 

这种方式是不是有点类似于lodash的对象/数组查找器呢?同理，我们也可以实现路径赋值器，如下所示：

1. let setObjAttr = function(obj, key, value){ 
2.     if(!obj) { 
3.         return false 
4.     } 
5.     let result = obj, 
6.     key = key.split('.'); 
7.     for(let i =0, len = key.length; i< len - 1; i++){ 
8.         if(result[key[i]] === undefined) { 
9.             result[key[i]] = {}; 
10.         } 
11.          
12.         if(!(result[key[i]] instanceof Object)){ 
13.             // 如果第i层对应的不是一个对象，则剖出错误 
14.             throw new Error('is not Object') 
15.             return false 
16.         } 
17.          
18.         result = result[key[i]] 
19.     } 
20.     return result[key[i]] = val 
21. } 
22.  
23. // 使用 
24. setObjAttr(obj, 'a.b.c.d', 'xuxi') 

5.如何用迭代器的思想解决分支循环嵌套问题

分支循环嵌套的问题主要是指在循环体中还需要进行额外的判断，如果判断条件变多，将会造成严重的性能开销问题，如下面的例子：

1. // 数据分组 
2. function group(name, num) { 
3.     let data = []; 
4.     for(let i = 0; i < num; i++){ 
5.         switch(name) { 
6.             case 'header': 
7.                data[i][0] = 0; 
8.                data[i][1] = 1; 
9.                break; 
10.            case 'content': 
11.                data[i][0] = 2; 
12.                data[i][1] = 3; 
13.                break; 
14.            case 'footer': 
15.                data[i][0] = 4; 
16.                data[i][1] = 532; 
17.                break; 
18.            default: 
19.                break; 
20.         } 
21.     } 
22.     return data 
23. } 

由以上分析可知，上面的代码还有很多优化空间，因为每一次遍历都要进行一次分支判断，那么如果num变成100000，且name的种类有100种，那么我们就要做100000*100种无用的分支判断，这样无疑会让你的代码在大数据下卡死。不过我们可以通过以下这种方式优化它：

1. // 数据分组 
2. function group(name, num) { 
3.     let data = []; 
4.     let strategy = function() { 
5.         let deal = { 
6.             'default': function(i){ 
7.                 return 
8.             }, 
9.             'header': function(i){ 
10.                data[i][0] = 0; 
11.                data[i][1] = 1; 
12.             }, 
13.            'content': function(i){ 
14.                data[i][0] = 2; 
15.                data[i][1] = 3; 
16.             },  
17.             //... 
18.         } 
19.         return function(name) { 
20.             return deal[name] || deal['default'] 
21.         } 
22.     }(); 
23.     // 迭代器处理数据 
24.     function _each(fn) { 
25.        for(let i = 0; i < num; i++){ 
26.         fn(i) 
27.        } 
28.     } 
29.      
30.     _each(strategy(name)) 
31.      
32.     return data 
33. } 

这样我们就能避免分支判断，极大的提高了代码效率和性能。

6.实现一个图片播放器

图片播放器主要有以上几个功能，上一页，下一页，首页，尾页，自动播放按钮，停止按钮。具体组件的设计机构可以参考我写的demo：

1. // 图片播放器 
2. let imgPlayer = function(imgData, box) { 
3.     let container = box && document.querySelector(box) || document, 
4.     img = container.querySelector('img'), 
5.     // 获取图片长度 
6.     len = imgData.length, 
7.     // 当前索引值 
8.     index = 0; 
9.     // 初始化图片 
10.     img.src = imgData[0]; 
11.  
12.     var timer = null; 
13.  
14.     return { 
15.         // 获取第一个图片 
16.         first: function() { 
17.             index = 0 
18.             img.src = imgData[index] 
19.         }, 
20.         // 获取最后一个图片 
21.         last: function() { 
22.             index = len - 1 
23.             img.src = imgData[index] 
24.         }, 
25.         // 切换到前一张图片 
26.         pre: function() { 
27.             if(--index > 0) { 
28.                 img.src = imgData[index] 
29.             }else { 
30.                 index = 0 
31.                 img.src = imgData[index] 
32.             } 
33.         }, 
34.         // 切换到后一张图片 
35.         next: function() { 
36.             if(++index < len) { 
37.                 img.src = imgData[index] 
38.             }else { 
39.                 index = len - 1 
40.                 img.src = imgData[index] 
41.             } 
42.         }, 
43.         // 自动播放图片 
44.         play: function() { 
45.             timer = setInterval(() => { 
46.                 if(index > len - 1) { 
47.                     index = 0 
48.                 } 
49.                 img.src = imgData[index] 
50.                 index++ 
51.             }, 5000) 
52.         }, 
53.         // 停止播放图片 
54.         stop: function() { 
55.             clearInterval(timer) 
56.         } 
57.     } 
58. } 
59.  
60. // 使用 
61. let player = new imgPlayer(imgData, '#box') 

总之，迭代器思想和其他设计模式的组合，可以设计出各种各样高度配置的组件，所以说学好并理解 javascript 设计模式的精髓，决定了我们的高度和态度。

             原文地址：https://mp.weixin.qq.com/s/xuK7EEWXmno4zweGpy99iQ