什么是函数？
函数是一个过程：它须要一些叫做参数的输出，而后产生一些叫做返回值的输入。函数能够用于以下目标：
映射：基于输出值产生一些的输入。函数把输出值映射到输入值。
过程化：能够调用一个函数去执行一系列步骤。该一系列步骤称为过程，而这种形式的编程称为面向过程编程。
I/O：一些函数存在与零碎其余局部进行通信，例如屏幕，存储，系统日志或网络。
映射
纯函数都是对于映射的。函数将输出参数映射到返回值，这意味着对于每组输出，都存在对应的输入。函数将获取输出并返回相应的输入。
Math.max() 以一组数字作为参数并返回最大数字：
Math.max(2, 8, 5); // 8
复制代码
在此示例中，2，8 和 5 是参数。它们是传递给函数的值。
Math.max() 是一个能够承受任意数量的参数并返回最大参数值的函数。在这个案例中，咱们传入的最大数是 8，对应了返回的数字。
函数在计算和数学中十分重要。它们帮忙咱们用适合的形式解决数据。好的程序员会给函数起描述性的名称，以便当咱们查看代码时，咱们能够通过函数名理解函数的作用。
数学也有函数，它们的工作形式与 JavaScript 中的函数十分类似。您可能见过代数函数。他们看起来像这样：
f(x) = 2x
这意味着咱们要申明了一个名为 f 的函数，它承受一个叫 x 的参数并将 x 乘以 2。
要应用这个函数，咱们只需为 x 提供一个值：
f(2)
在代数中，这意味着与上面的写法完全相同：
4
因而，在任何看到 f(2) 的中央都能够替换 4。
当初让咱们用 JavaScript 来形容这个函数：
const double = x => x * 2;
复制代码
你能够应用 console.log() 查看函数输入：
console.log(double(5) ); // 10
复制代码
还记得我说过的在数学函数中，你能够替换 f(2) 为 4 吗？在这种状况下，JavaScript 引擎用 10 替换 double(5)。
因而，console.log(double(5) ); 与 console.log(10); 雷同
这是实在存在的，因为 double() 是一个纯函数，然而如果 double() 有副作用，例如将值保留到磁盘或打印到控制台，用 10 替换 double(5) 会扭转函数的含意。
如果想要援用通明，则须要应用纯函数。
纯函数
纯函数是一个函数，其中：
给定雷同的输出，将始终返回雷同的输入。
无副作用。
如果你正当调用一个函数，而没有应用它的返回值，则毫无疑问不是纯函数。对于纯函数来说，相当于未进行调用。
我倡议你偏差于应用纯函数。意思是，如果应用纯函数实现程序需要是可行的，应该优先选择应用。纯函数承受一些输出，并依据输出返回一些输入。它们是程序中最简略的可重用代码块。兴许计算机科学中最重要的设计原理是 KISS（放弃简单明了）。我更喜爱放弃傻瓜式的简略。纯函数是傻瓜式简略的最佳形式。
纯函数具备许多无益的个性，并形成了函数式编程的根底。纯函数齐全独立于内部状态，因而，它们不受所有与共享可变状态无关问题的影响。它们的独立个性也使其成为跨多个 CPU 以及整个分布式计算集群进行并行处理的极佳抉择，这使其对许多类型的迷信和资源密集型计算工作至关重要。
纯函数也是十分独立的 —— 在代码中能够轻松挪动，重构以及重组，使程序更灵便并可能适应未来的更改。
共享状态问题
几年前，我正在开发一个应用程序，该程序容许用户搜寻艺术家的数据库，并将该艺术家的音乐播放列表加载到 Web 播放器中。大概在 Google Instant 上线的那个时候，当输出搜寻查问时，它会显示即时搜寻后果。AJAX 驱动的主动实现性能风行一时。
惟一的问题是，用户输出的速度通常快于 API 的主动实现搜寻并返回响应的速度，从而导致一些奇怪的谬误。这将触发竞争条件（race condition），在此状况下，较新的后果可能会被过期的所取代。
为什么会这样呢？因为每个 AJAX 胜利处理程序都有权间接更新显示给用户的倡议列表。最慢的 AJAX 申请总是能够通过自觉替换取得用户的留神，即便这些替换的后果可能是较新的。
为了解决这个问题，我创立了一个倡议管理器 —— 一个繁多数据源去治理查问倡议的状态。它晓得以后有一个待处理的 AJAX 申请，并且当用户输出新内容时，这个待处理的 AJAX 申请将在收回新申请之前被勾销，因而一次只有一个响应处理程序将可能触发 UI 状态更新。
任何品种的异步操作或并发都可能导致相似的竞争条件。如果输入取决于不可控事件的程序（例如网络，设施提早，用户输出，随机性等），则会产生竞争条件。实际上，如果你正在应用共享状态，并且该状态依赖于一系列不确定性因素，总而言之，输入都是无奈预测的，这意味着无奈正确测试或齐全了解。正如 Martin Odersky（Scala 语言的创建者）所说：
不确定性 = 并行处理 + 可变状态
程序的确定性通常是计算中的现实属性。可能你认为还好，因为 JS 在单线程中运行，因而不受并行处理问题的影响，然而正如 AJAX 示例所示，单线程 JS 引擎并不意味着没有并发。相同，JavaScript 中有许多并发起源。API I/O，事件侦听，Web Worker，iframe 和超时都能够将不确定性引入程序中。将其与共享状态联合起来，就能够得出解决 bug 的办法。
纯函数能够帮忙你防止这些 bug。
给定雷同的输出，始终返回雷同的输入
应用下面的 double() 函数，你能够用后果替换函数调用，程序依然具备雷同的含意 —— double(5) 始终与程序中的 10 具备雷同含意，而不论上下文如何，无论调用它多少次或何时调用。
然而你不能对所有函数都这么认为。某些函数依赖于你传入的参数以外的信息来产生后果。
思考以下示例：
Math.random(); // => 0.4011148700956255
Math.random(); // => 0.8533405303023756
Math.random(); // => 0.3550692005082965
复制代码
只管咱们没有传递任何参数到任何函数调用的，他们都产生了不同的输入，这意味着 Math.random() 是不是纯函数。
Math.random() 每次运行时，都会产生一个介于 0 和 1 之间的新随机数，因而很显著，你不能只用 0.4011148700956255 替换它而不改变程序的含意。
那将每次都会产生雷同的后果。当咱们要求计算机产生一个随机数时，通常意味着咱们想要一个与上次不同的后果。每一面都印着雷同数字的一对骰子有什么意义呢？
有时咱们必须询问计算机以后工夫。咱们不会具体地理解工夫函数的工作原理。只需复制以下代码：
const time = () => new Date().toLocaleTimeString();
time(); // => “5:15:45 PM”
复制代码
如果用以后工夫取代 time() 函数的调用会产生什么？
它总是输入雷同的工夫：这个函数调用被替换的工夫。换句话说，它只能每天产生一次正确的输入，并且仅当你在替换函数的确切时刻运行程序时才能够。前端培训
很显著，time() 不像 double() 函数。
如果函数在给定雷同的输出的状况下始终产生雷同的输入，则该函数是纯函数。你可能还记得代数课上的这个规定：雷同的输出值将始终映射到雷同的输入值。然而，许多输出值可能会映射到雷同的输入值。例如，以下函数是纯函数：
const highpass = (cutoff, value) => value >= cutoff;
复制代码
雷同的输出值将始终映射到雷同的输入值：
highpass(5, 5); // => true
highpass(5, 5); // => true
highpass(5, 5); // => true
复制代码
许多输出值可能映射到雷同的输入值：
highpass(5, 123); // true
highpass(5, 6); // true
highpass(5, 18); // true
highpass(5, 1); // false
highpass(5, 3); // false
highpass(5, 4); // false
复制代码
纯函数肯定不能依赖任何内部可变状态，因为它不再是确定性的或援用通明的。
纯函数不会产生副作用
纯函数不会产生任何副作用，意味着它无奈更改任何内部状态。
不变性
JavaScript 的对象参数是援用的，这意味着如果函数更改对象或数组参数上的属性，则将使该函数内部可拜访的状态发生变化。纯函数不得扭转内部状态。
考虑一下这种扭转的，不纯的 addToCart() 函数：
// 不纯的 addToCart 函数扭转了现有的 cart 对象
const addToCart = (cart, item, quantity) => {
cart.items.push({
item,
quantity});
return cart;
};
test(‘addToCart()’, assert => {
const msg = ‘addToCart() should add a new item to the cart.’;
const originalCart = {
items: []};
const cart = addToCart(
originalCart,
{
name: "Digital SLR Camera",
price: '1495'
},
1);
const expected = 1; // cart 中的商品数
const actual = cart.items.length;
assert.equal(actual, expected, msg);
assert.deepEqual(originalCart, cart, ‘mutates original cart.’);
assert.end();
});
复制代码
这个函数通过传递 cart 对象，增加商品和商品数量到 cart 对象上来调用的。而后，该函数返回雷同的 cart 对象，并增加了商品。
这样做的问题是，咱们刚刚扭转了一些共享状态。其余函数可能依赖于 cart 对象状态 —— 被该函数调用之前的状态，而当初咱们曾经更改了这个共享状态，如果咱们扭转函数调用的程序，咱们不得不放心将会对程序逻辑上产生怎么的影响。重构代码可能会导致 bug 呈现，从而可能毁坏订单并导致客户不称心。
当初思考这个版本：
// 纯 addToCart() 函数返回一个新的 cart 对象
// 这不会扭转原始对象
const addToCart = (cart, item, quantity) => {
const newCart = lodash.cloneDeep(cart);
newCart.items.push({
item,
quantity});
return newCart;
};
test(‘addToCart()’, assert => {
const msg = ‘addToCart() should add a new item to the cart.’;
const originalCart = {
items: []};
// npm 上的 deep-freeze
// 如果原始对象被扭转，则抛出一个谬误
deepFreeze(originalCart);
const cart = addToCart(
originalCart,
{
name: "Digital SLR Camera",
price: '1495'
},
1);
const expected = 1; // cart 中的商品数
const actual = cart.items.length;
assert.equal(actual, expected, msg);
assert.notDeepEqual(originalCart, cart,
'should not mutate original cart.');assert.end();
});
复制代码
在此示例中，咱们在对象中嵌套了一个数组，这是我要进行深克隆的起因。这比你通常要解决的状态更为简单。对于大多数事件，你能够将其合成为较小的块。
例如，Redux 让你能够组成 reducers，而不是在每个 reducers 中的解决整个应用程序状态。后果是，你不用每次更新整个应用程序状态的一小部分时就创立一个深克隆。相同，你能够应用非破坏性数组办法，或 Object.assign() 更新利用状态的一小部分。