|
|
|
|
公众号矩阵

帮你精通JS:一段函数的进化史

我们以memorization的方式求factorial而遭遇over-exposure的问题,由此引出priciple-of-lease-exposure的原则。作为解决方案,直觉的做法是将其包裹在外层函数之内,不足之处在于需要重新declare函数。进一步解决问题,省略掉重新declare与assignment,用IIFE,在定义的同时也实现定义。

作者:权哥编程来源:今日头条|2021-04-08 09:14

一、首先写一段求阶乘的函数

用 memozation实现一段factorial

  1. > var cache = {}; 
  2. function factorial(x) { 
  3. ...     if (x < 2) return 1; 
  4. ...     if (!(x in cache)) { 
  5. .....         cache[x] = x * factorial(x - 1); 
  6. .....     } 
  7. ...     return cache[x]; 
  8. ... } 
  9. > factorial(8) 
  10. 40320 
  11. > cache 
  12. '2': 2, '3': 6, '4': 24, '5': 120, '6': 720, '7': 5040, '8': 40320 } 

此处 cache 只用于函数 factorial 之内,却过分暴露于外。按照 least exposure(POLE) 将其隐藏起来。直觉方法就是直接将其放入其中。

二、初步解决接口过分暴露的问题

重新定义最外层coverTheCache函数将其包裹起来。

  1. function coverTheCache() { 
  2. ...     // "middle scope"where we cover `cache` 
  3. ...     var cache = {}; 
  4. ... 
  5. ...     return factorial; 
  6. ... 
  7. ...     // ********************** 
  8. ... 
  9. ...     function factorial(x) { 
  10. ...         // inner scope 
  11. ...         if (x < 2) return 1; 
  12. ...         if (!(x in cache)) { 
  13. .....             cache[x] = x * factorial(x - 1); 
  14. .....         } 
  15. ...         return cache[x]; 
  16. ...     } 
  17. ... } 

运行测试:

  1. > let factorial2 = coverTheCache(); 
  2. > factorial2(9) 
  3. 362880 
  4. > factorial(10) 
  5. 3628800 

此解决方案完全符合直觉,就是单单的将步骤一中的factorial函数与变量cache收纳到另外一个函数coverTheCache的肚子里,包裹了一层环境。

缺憾之处在于,`let factorial2 = hideTheCache();`此处还要另行调用。因此,接下来将重新declare与赋值的这一步去掉。

三、IIFE解决过分暴露的问题

  1. > const factorial3 = (function coverTheCache() { 
  2. ...     var cache = {}; 
  3. ... 
  4. ...     function factorial(x) { 
  5. ...         if (x < 2) return 1; 
  6. ...         if (!(x in cache)) { 
  7. .....             cache[x] = x * factorial(x - 1); 
  8. .....         } 
  9. ...         return cache[x]; 
  10. ...     } 
  11. ... 
  12. ...     return factorial; 
  13. ... })(); // 关键步骤 
  14. undefined 
  15. > factorial3(11) 
  16. 39916800 
  17. > factorial(300) 
  18. Infinity 
  19. > factorial(30) 
  20. 2.6525285981219103e+32 

如此就不必再另行一步调用,该方法称之为 IIFE(

Immediately-Invoked-Function-Expression):

  1. // outer scope 
  2. (function(){ 
  3.     // inner hidden scope 
  4. })(); 
  5. // more outer scope 

四、总结

我们以memorization的方式求factorial而遭遇over-exposure的问题,由此引出

priciple-of-lease-exposure的原则。

作为解决方案,直觉的做法是将其包裹在外层函数之内,不足之处在于需要重新declare函数。进一步解决问题,省略掉重新declare与assignment,用IIFE,在定义的同时也实现定义。

以上就是factorial这个函数进化的三个步骤。

【编辑推荐】

  1. 换掉Java的老牌日志框架Logback,我用Log4j2!
  2. 历时近 20 年,SCO 和 IBM 间的 Unix 纠纷再起
  3. 轻量级NLP工具开源,中文处理更精准,超越斯坦福Stanza
  4. 统治50年:为什么SQL在如今仍然很重要?
  5. 如何成为多编程语言人才?这有一份独门诀窍
【责任编辑:姜华 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

订阅专栏+更多

数据湖与数据仓库的分析实践攻略

数据湖与数据仓库的分析实践攻略

助力现代化数据管理:数据湖与数据仓库的分析实践攻略
共3章 | 创世达人

7人订阅学习

云原生架构实践

云原生架构实践

新技术引领移动互联网进入急速赛道
共3章 | KaliArch

37人订阅学习

数据中心和VPDN网络建设案例

数据中心和VPDN网络建设案例

漫画+案例
共20章 | 捷哥CCIE

231人订阅学习

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊

51CTO服务号

51CTO官微