JavaScript ES6函数式编程（一）：闭包与高阶函数

帮光头强打熊大 發表於 2019-10-20 14:32:00

JavaScript ES6函数式编程（一）：闭包与高阶函数

<h3 id="函数式编程的历史">函数式编程的历史</h3>
函数的第一原则是要小，第二原则则是要更小 —— ROBERT C. MARTIN
解释一下上面那句话，就是我们常说的一个函数只做一件事，比如：将字符串首字母和尾字母都改成大写，我们此时应该编写两个函数。为什么呢？为了更好的复用，这样做保证了函数更加的颗粒化。
早在 1950 年代，随着 Lisp 语言的创建，函数式编程（ Functional Programming，简称 FP）就已经开始出现在大家视野。而直到近些年，函数式以其优雅，简单的特点开始重新风靡整个编程界，主流语言在设计的时候无一例外都会更多的参考函数式特性（ Lambda 表达式，原生支持 map ，reduce ……），Java8 开始支持函数式编程。
而在前端领域，我们同样能看到很多函数式编程的影子：Lodash.js、Ramda.js库的广泛使用，ES6 中加入了箭头函数，Redux 引入 Elm 思路降低 Flux 的复杂性，React16.6 开始推出 React.memo()，使得 pure functional components 成为可能，16.8 开始主推 Hooks，建议使用 pure functions 进行组件编写……
这些无一例外的说明，函数式编程这种古老的编程范式并没有随着岁月而褪去其光彩，反而愈加生机勃勃。
<h3 id="什么是函数式编程">什么是函数式编程</h3>
上面我们了解了函数式编程的历史，确定它是个很棒的东西。接下来，我们要去了解一下什么是函数式编程？
其实函数我们从小就学，什么一元函数（<code>f(x) = 3x</code>），二元函数……根据学术上函数的定义，函数即是一种描述集合和集合之间的转换关系，输入通过函数都会返回有且只有一个输出值。
所以，函数实际上是一个关系，或者说是一种映射，而这种映射关系是可以组合的，一旦我们知道一个函数的输出类型可以匹配另一个函数的输入，那他们就可以进行组合。
在编程的世界里，我们需要处理其实也只有“数据”和“关系”，而“关系”就是函数，“数据”就是要传入的实参。我们所谓的编程工作也不过就是在找一种映射关系，比如：将字符串首字母转为大写。一旦关系找到了，问题就解决了，剩下的事情，就是让数据流过这种关系，然后转换成另一个数据返回给我们。
想象一个流水线车间的工作过程，把输入当做原料，把输出当做产品，数据可以不断的从一个函数的输出可以流入另一个函数输入，最后再输出结果，这不就是一套流水线嘛？
所以，现在你明确了函数式编程是什么了吧？它其实就是强调在编程过程中把更多的关注点放在如何去构建关系。通过构建一条高效的建流水线，一次解决所有问题。而不是把精力分散在不同的加工厂中来回奔波传递数据。
参考链接：阮一峰 - 函数式编程入门教程
<h3 id="函数式编程的特点">函数式编程的特点</h3>
<ul>
<li>函数是一等公民</li>
</ul>
根据维基百科，编程语言中一等公民的概念是由英国计算机学家Christopher Strachey提出来的，时间则早在上个世纪60年代，那个时候还没有个人电脑，没有互联网，没有浏览器，也没有JavaScript。并且当时也没给出清晰的定义。
关于一等公民，我找到一个权威的定义，来自于一本书《Programming Language Pragmatics》，这本书是很多大学的程序语言设计的教材。
<blockquote>
In general, a value in a programming language is said to have ﬁrst-class status if it can be passed as a parameter, returned from a subroutine, or assigned into a variable.
</blockquote>
也就是说，在编程语言中，一等公民可以作为函数参数，可以作为函数返回值，也可以赋值给变量。
例如，字符串在几乎所有编程语言中都是一等公民，字符串可以做为函数参数，字符串可以作为函数返回值，字符串也可以赋值给变量。
对于各种编程语言来说，函数就不一定是一等公民了，比如Java 8之前的版本。
对于JavaScript来说，函数可以赋值给变量，也可以作为函数参数，还可以作为函数返回值，因此JavaScript中函数是一等公民。
<ul>
<li>声明式编程 (Declarative Programming)</li>
</ul>
通过上面的例子可以看出来，函数式编程大多时候都是在声明我需要做什么，而非怎么去做。这种编程风格称为**声明式编程 **。
<pre><code>// 比如：我们要打印数组中的每个元素
// 1. 命令式编程
let arr = ;
for (let i = 0, len = arr.length; i < len; i++) {
console.log(arr)
}

// 2. 声明式编程
let arr = ;
arr.forEach(item => {
console.log(item)
})

/*
* 相对于命令式编程的 for 循环拿到每个元素，声明式编程不需要自己去找每个元素
* 因为 forEach 已经帮我们拿到了，就是 item，直接打印出来就行
*/
</code></pre>
这样有个好处是代码的可读性特别高，因为声明式代码大多都是接近自然语言的，同时，它解放了大量的人力，因为它不关心具体的实现，因此它可以把优化能力交给具体的实现，这也方便我们进行分工协作。
<ul>
<li>惰性执行（Lazy Evaluation）</li>
</ul>
所谓惰性执行指的是函数只在需要的时候执行，即不产生无意义的中间变量。
<ul>
<li>无状态和数据不可变 (Statelessness and Immutable data)</li>
</ul>
这是函数式编程的核心概念：
数据不可变：它要求你所有的数据都是不可变的，这意味着如果你想修改一个对象，那你应该创建一个新的对象用来修改，而不是修改已有的对象。 
**无状态： **主要是强调对于一个函数，不管你何时运行，它都应该像第一次运行一样，给定相同的输入，给出相同的输出，完全不依赖外部状态的变化。
<ul>
<li>没有副作用(side effect)</li>
</ul>
副作用，一般指完成分内的事情之后还带来了不好的影响。在函数中，最常见的副作用就是随意修改外部变量。由于js对象传递的是引用地址，这很容易带来bug。
例如： map 函数的本来功能是将输入的数组根据一个函数转换，生成一个新的数组。而在 JS 中，我们经常可以看到下面这种对 map 的 “错误” 用法，把 map 当作一个循环语句，然后去直接修改数组中的值。
<pre><code>const list = [...];
// 修改 list 中的 type 和 age
list.map(item => {
item.type = 1;
item.age++;
})
</code></pre>
<blockquote>
传递引用一时爽，代码重构火葬场
</blockquote>
这样函数最主要的输出功能没有了，变成了直接修改了外部变量，这就是它的副作用。而没有副作用的写法应该是：
<pre><code>const list = [...];
// 修改 list 中的 type 和 age
const newList = list.map(item => ({...item, type: 1, age:item.age + 1}));
</code></pre>
保证函数没有副作用，一来能保证数据的不可变性，二来能避免很多因为共享状态带来的问题。当你一个人维护代码时候可能还不明显，但随着项目的迭代，项目参与人数增加，大家对同一变量的依赖和引用越来越多，这种问题会越来越严重。最终可能连维护者自己都不清楚变量到底是在哪里被改变而产生 Bug。
<ul>
<li>纯函数 (pure functions)</li>
</ul>
函数式编程最关注的对象就是纯函数，纯函数的概念有两点：
不依赖外部状态（无状态）： 函数的的运行结果不依赖全局变量，this 指针，IO 操作等。 
没有副作用（数据不变）： 不修改全局变量，不修改入参。
所以纯函数才是真正意义上的 “函数”，它也遵循引用透明性——相同的输入，永远会得到相同的输出。
我们这么强调使用纯函数，纯函数的意义是什么？
便于测试和优化：这个意义在实际项目开发中意义非常大，由于纯函数对于相同的输入永远会返回相同的结果，因此我们可以轻松断言函数的执行结果，同时也可以保证函数的优化不会影响其他代码的执行。这十分符合测试驱动开发 TDD（Test-Driven Development ) 的思想，这样产生的代码往往健壮性更强。
可缓存性：因为相同的输入总是可以返回相同的输出，因此，我们可以提前缓存函数的执行结果，有很多库有所谓的 memoize 函数，下面以一个简化版的 memoize 为例，这个函数就能缓存函数的结果，对于像 fibonacci 这种计算，就可以起到很好的缓存效果。
<pre><code>function memoize(fn) {
const cache = {};
return function() {
 const key = JSON.stringify(arguments);
 var value = cache;
 if(!value) {
 value = ;// 放在一个数组中，方便应对 undefined，null 等异常情况
 cache = value;
 }
 return value;
}
}

const fibonacci = memoize(n => n < 2 ? n: fibonacci(n - 1) + fibonacci(n - 2));
console.log(fibonacci(4))// 执行后缓存了 fibonacci(2), fibonacci(3),fibonacci(4)
console.log(fibonacci(10)) // fibonacci(2), fibonacci(3),fibonacci(4) 的结果直接从缓存中取出，同时缓存其他的
</code></pre>
<h3 id="闭包">闭包</h3>
定义：一个能够读取其他函数内部变量的函数，实质是变量的解析过程（由内而外）
闭包是ES中一个离不开的话题，而且也是是一个难懂又必须搞明白的概念！说起闭包，就不得不提与它密切相关的变量作用域和变量的生命周期。下面来看下：
<h4 id="变量作用域">变量作用域</h4>
变量作用域分为两类：全局作用域和局部作用域。
<ul>
<li>编写在script标签中的变量或者没用var关键字声明的变量，就代表全局变量，在页面的任意位置都可以访问到</li>
<li>在函数中声明变量带有var关键字的即是局部变量，局部变量只能在函数内才能访问到</li>
</ul>
<pre><code>function fn() {
var a = 1; // a为局部变量
console.log(a);// 1
}
fn();
console.log(a); // a is not defined外部访问不到内部的变量
</code></pre>
上面代码展示了在函数中声明的局部变量a在函数外部拿不到。可是我们就想要在函数外拿到它，怎么办？下面就要看发挥闭包的威力了。
函数可以创造函数作用域，在函数作用域中如果要查找一个变量的时候，如果在该函数内没有声明这个变量，就会向该函数的外层继续查找，一直查到全局变量为止。
所以变量的查找是由内而外的，这也形成了所谓的作用域链。
<pre><code>var a = 7;
function outer() {
var b = 8;
function inner() {
 var c = 9;
 alert(b);
 alert(a);
}
inner();
alert(c); // c is not defined
}
outer(); // 调用函数
</code></pre>
还是最开始的函数，利用作用域链，我们试着去拿到a，改造一下fn函数：
<pre><code>function fn() {
var a = 1; // a为局部变量
return function() {
 console.log(a);
}
}
var fn2 = fn();
fn2(); // 1
</code></pre>
理解了变量作用域，顺着这条作用域链，再来回顾一下闭包的定义：**闭包就是能够读取其他函数内部变量的函数，实质是变量的解析过程（由内而外）**
<h4 id="变量生命周期">变量生命周期</h4>
理解了变量作用域，再来看看变量的生命周期，直白一点就是它能在程序中存活多久。
<ul>
<li>对于全局变量而言，它的生命周期机就是永久的，除非我们手动销毁它（这一点也是很有必要的，防止内存溢出）</li>
<li>对于在函数中通过var声明的变量而言，就没那么幸运了。当函数执行完毕后，它也就没什么利用价值了，随之被浏览器的垃圾处理机制当垃圾处理掉了 
比如下面这段代码：</li>
</ul>
<pre><code>var forever = 'i am forever exist'// 全局变量，永生
function fn() {
var a = 123; // fn执行完毕后，变量a就将被销毁了
console.log(a);
}
fn();
</code></pre>
函数执行完毕，内部的变量a就被无情的销毁了。那么我们有没有办法拯救这个变量呢？答案是肯定的，救星来了——闭包
<h4 id="闭包的创建">闭包的创建</h4>
<pre><code>function outFn() {
var i = 1;
function inFn () {
 return ++i
}
return inFn;
}
var fn = outFn(); // 此处创建了一个闭包
fn(); // 2
fn(); // 3
fn(); // 4
</code></pre>
上面的代码创建了一个闭包，有两个特点：
<ol>
<li>函数inFn嵌套在函数outFn内部</li>
<li>函数outFn返回内部函数inFn</li>
</ol>
在执行完<code>var fn = outFn();</code>后，变量 fn 实际上是指向了函数 inFn，再执行 fn( ) 后就会返回 i 的值（第一次为1）。这段代码其实就创建了一个闭包，这是因为函数 outFn 外的变量 fn 引用了函数 outFn 内的函数inFn。也就是说，当函数 outFn 的内部函数 inFn 被函数 outFn 外的一个变量 fn 引用的时候，就创建了一个闭包（函数内部的变量 i 被保存到内存中，不会被立即销毁）。
参考链接： 
闭包的创建 
闭包和内存
<h3 id="高阶函数">高阶函数</h3>
定义：高阶函数就是接受函数作为参数或者返回函数作为输出的函数。
下面分两种情况讲解，搞清这两种应用场景，这将有助于理解并运用高阶函数。
<h4 id="函数作为参数传入">函数作为参数传入</h4>
函数作为参数传入最常见的就是回调函数。例如：在 ajax 异步请求的过程中，回调函数使用的非常频繁。因为异步执行不能确定请求返回的时间，将callback回调函数当成参数传入，待请求完成后执行 callback 函数。
<pre><code>$.ajax({
url: 'http://musicapi.leanapp.cn/search',// 以网易云音乐为例
data: {
 keywords
},
success: function (res) {
 callback && callback(res.result.songs);
}
})
</code></pre>
<h4 id="函数作为返回值输出">函数作为返回值输出</h4>
函数作为返回值输出的应用场景那就太多了，这也体现了函数式编程的思想。其实从闭包的例子中我们就已经看到了关于高阶函数的相关内容了。
还记得在我们去判断数据类型的时候，我们都是通过<code>Object.prototype.toString</code>来计算的，每个数据类型之间只是<code>''</code>不一样而已。
下面我们封装一个高阶函数，实现对不同类型变量的判断：
<pre><code>function isType (type) {
return function (obj) {
 return Object.prototype.toString.call(obj) === `
}
}

const isArray = isType('Array'); // 判断数组类型的函数
const isString = isType('String'); // 判断字符串类型的函数
console.log(isArray(); // true
console.log(isString({});// false
</code></pre>
参考链接： 
高阶函数，你怎么那么漂亮呢！ 
简明 JavaScript 函数式编程——入门篇
<h3 id="总结">总结</h3>
最后总结一下这次的重点：纯函数、变量作用域、闭包、高阶函数。
<ol>
<li>纯函数的定义：给定的输入返回相同的输出的函数。</li>
<li>变量作用域是闭包的实质。根据变量作用域向上查找的特性，闭包可以缓存变量到内存中，函数执行完毕不会立即销毁。</li>
<li>高阶函数的核心是闭包，利用闭包缓存一些未来会用到的变量，可以实现柯里化、偏应用...</li>
</ol>
下一节介绍柯里化、偏应用、组合、管道... 
来源：https://www.cnblogs.com/chenwenhao/p/11668894.html

頁: [1]

琼殿技术论坛's Archiver

JavaScript ES6函数式编程（一）：闭包与高阶函数