摘要：在函數(shù)式編程語言中，這一特性可用于構(gòu)造無限列表。學(xué)習(xí)網(wǎng)址，是一個擁有和函數(shù)的數(shù)據(jù)類型，類似于，但它會輸出非嵌套形式的結(jié)果在其他函數(shù)式編程語言中，也被稱為，也被稱為和。

原文連接

[TOC]

指函數(shù)的參數(shù)數(shù)量，由 -ary 和 -ity 這兩個英文后綴拼接而成：

const sum = (a, b) => a + b;
const Arity = sum.length;
console.log(Arity);
// 輸出結(jié)果為 2

高階函數(shù)，此類函數(shù)可以接收其他函數(shù)作為參數(shù)，也可以返回一個函數(shù)作為返回值：

const filter = (predFunc, list) => {
  const results = [];
  list.forEach((listItem) => {
    if (predFunc(listItem)) {
      results.push(listItem);
    }
  });
  return results;
}
// filter 這個函數(shù)就是將一個函數(shù)作為參數(shù)傳入
// 但這都么有什么，主要是后面is函數(shù)返回一個函數(shù)

const is = (type) => (x) => Object(x) instanceof type;
// is這個函數(shù)就是將一個函數(shù)作為返回值返回到下面的調(diào)用之中

filter(is(Number), [0, "1", 2, null]);
// 上面函數(shù)調(diào)用的結(jié)果是 [0, 2]

偏函數(shù)，在原函數(shù)的基礎(chǔ)上預(yù)填充（pre-filling）部分參數(shù)并返回的新函數(shù)：

// 下面是一個創(chuàng)建偏函數(shù)的輔助函數(shù)，下面函數(shù)將一個函數(shù)和這個函數(shù)所需要的除了最后一個參數(shù)的參數(shù)傳入，返回一個新的函數(shù)，這個新的函數(shù)的參數(shù)為原函數(shù)的最后一個參數(shù)
const partial = (func, ...args) => (...moreArgs) => func(...args, ...moreArgs);
// 寫一個將三個數(shù)字相加的函數(shù)
const add3 = (a, b, c) => a + b + c;
// 預(yù)填充 (add3, 2, 3) 三個參數(shù)，空置最后一個參數(shù)，返回一個新的函數(shù)，重點是返回一個新的函數(shù)
const fivePlus = partial(add3, 2, 3); // (c) => 2 + 3 + c
fivePlus(4);
// => 9

柯里化，將一個接收多個參數(shù)的函數(shù)轉(zhuǎn)化為單參數(shù)函數(shù)的方式，轉(zhuǎn)化后的函數(shù)每次只接收一個參數(shù)，然后返回一個新函數(shù)，新函數(shù)可以繼續(xù)接收參數(shù)，直到接收到所有的參數(shù)：

const sum = (a, b) => a + b;
sum(2, 3);
// => 6
const curriedSum = (a) => (b) => a + b;
curriedSum(40)(2);
// => 42.
const add2 = curriedSum(2);
// (b) => 2 + b
add2(10);
// => 12

函數(shù)合成，接收多個函數(shù)作為參數(shù)并返回一個新函數(shù)的方式，新函數(shù)按照傳入的參數(shù)順序，從右往左依次執(zhí)行，前一個函數(shù)的返回值是后一個函數(shù)的輸入值：

const compose = (f, g) => (a) => f(g(a));
const floorAndToString = compose((val) => val.toString(), Math.floor);
floorAndToString(121.212121);
// => "121"

一個純函數(shù)需要滿足兩個條件，第一是函數(shù)的返回值只能由輸入值（函數(shù)接收的參數(shù)）決定，也就是說純函數(shù)接收相同的參數(shù)會返回相同的值；第二是純函數(shù)不會對自身作用域之外的運行環(huán)境產(chǎn)生副作用（side effects），比如說不會改變外部環(huán)境中變量的值，這會被認(rèn)為是不安全的行為：
純函數(shù)示例：

const greet = (name) => "Hi, " + name ;
greet("Brianne")
// => "Hi, Brianne"

如果函數(shù)或表達式與其自身作用域之外的可變數(shù)據(jù)（mutable data）發(fā)生了讀寫操作，那么此時函數(shù)和表達式就產(chǎn)生了副作用：

let greeting;
const greet = () => greeting = "Hi, " + window.name;
// greet() 執(zhí)行時更改了外部環(huán)境的變量
greet();
// => "Hi, Brianne"
// new Date() 是可變數(shù)據(jù)
const differentEveryTime = new Date();

point-free style 是一種不顯式向函數(shù)傳遞參數(shù)的代碼風(fēng)格，通常需要柯里化和高階函數(shù)來實現(xiàn)：

const map = (fn) => (list) => list.map(fn);
const add = (a) => (b) => a + b;
// Not points-free
// numbers 是一個顯式傳遞的參數(shù)
const incrementAll = (numbers) => map(add(1))(numbers);
// Points-free
// add(1) 的返回值隱式傳遞給了 map，作為 map 的 list 參數(shù)
const incrementAll2 = map(add(1));

斷言，一個返回布爾值的函數(shù)：

const predicate = (a) => a > 2;
[1, 2, 3, 4].filter(predicate);
// => [3, 4]

常量，初始化后不能再次執(zhí)行賦值操作的數(shù)據(jù)類型：

const five = 5;
const john = { name: "John", age: 30 };
// 因為常量不可變，所以下面表達式一定為 true
john.age + five === ({ name: "John", age: 30 }).age + (5);

常量具有 referentially transparent 的特性，也就是說將程序中出現(xiàn)的常量替換為它們實際的值，并不會影響程序的結(jié)果。譯者話外：實際上在 JavaScript 中的 const 所聲明的常量并不是完全穩(wěn)定的，使用 Immutable.js 演示更加恰當(dāng)：

// 這里的fromJS(), get()函數(shù)都是immutable.js所提供的方法
const five = fromJS(5);
const john = fromJS({name: "John", age: 30});
john.get("age") + five === ({ name: "John", age: 30 }).age + (5);

functor 都擁有 map 函數(shù)，并且在執(zhí)行 map 之后會返回一個新的 functor:

object.map(x => x) === object;
object.map(x => f(g(x))) === object.map(g).map(f);

JavaScript 中最常見的 functor 就是數(shù)組類型的實例：

[1, 2, 3].map(x => x);
// => [1, 2, 3]
const f = x => x + 1;
const g = x => x * 2;
[1, 2, 3].map(x => f(g(x)));
// => [3, 5, 7]
[1, 2, 3].map(g).map(f);     
// => [3, 5, 7]

lift 發(fā)生在你將值放入 functor 的時候，如果你將函數(shù) lift 進了 Applicative Functor，那么就可以使用這個函數(shù)處理傳遞給這個 functor 的值。某些 lift 的實現(xiàn)擁有 lift 或 liftA2 函數(shù)，便于在 functor 上執(zhí)行相關(guān)的函數(shù)：

const mult = (a, b) => a * b;
const liftedMult = lift(mult);
// => this function now works on functors like array
liftedMult([1, 2], [3]);
// => [3, 6]
lift((a, b) => a + b)([1, 2], [3, 4]);
// => [4, 5, 5, 6]

lift 一個單參數(shù)的函數(shù)非常類似于 map 操作：

const increment = (x) => x + 1;
lift(increment)([2]);
// => [3]
[2].map(increment);
// => [3]

匿名函數(shù)，本質(zhì)上是一個 value：

function(a){
  return a + 1;
};
(a) => a + 1;
// Lambda 常用語高階函數(shù)中
[1, 2].map((a) => a + 1);
// = [2, 3]
// Lambda 作為 value 被賦值給變量
let addOne = (a) => a + 1;

惰性求值，是一種按需執(zhí)行的求值策略，只有需要某個值時才會執(zhí)行相關(guān)的表達式。在函數(shù)式編程語言中，這一特性可用于構(gòu)造無限列表。

const rand = function*() {
    while (true) {
        yield Math.random();
    }
}
const randIter = rand();
randIter.next().value;
// 每次執(zhí)行 next() 函數(shù)都會返回一個新的隨機數(shù)
// 有且只有在執(zhí)行 next() 的時候才會返回新值
// function* 聲明（function關(guān)鍵字后跟一個星號）定義一個generator
// （生成器）函數(shù)，返回一個Generator對象。
// 學(xué)習(xí)網(wǎng)址：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Statements/function*

Monad，是一個擁有 of 和 chain 函數(shù)的數(shù)據(jù)類型，chain 類似于 map，但它會輸出非嵌套形式的結(jié)果：

["cat,dog", "fish,bird"].chain((a) => a.split(","))
// => ["cat", "dog", "fish", "bird"]
["cat,dog", "fish,bird"].map((a) => a.split(","))
// => [["cat", "dog"], ["fish", "bird"]]

在其他函數(shù)式編程語言中，of 也被稱為 return，chain 也被稱為 flatmap 和 bind。

同構(gòu)轉(zhuǎn)換，相同數(shù)據(jù)下不同結(jié)構(gòu)之間的轉(zhuǎn)換。舉例來說，2D 坐標(biāo)既可以存儲為數(shù)組 [2, 3] 也可以存儲為 { x: 2, y: 3 }：

const pairToCoords = (pair) => ({x: pair[0], y: pair[1]})
const coordsToPair = (coords) => [coords.x, coords.y]
coordsToPair(pairToCoords([1, 2]))
// => [1, 2]
pairToCoords(coordsToPair({x: 1, y: 2}))
// => { x: 1, y: 2 }

Setoid，擁有 equals 函數(shù)的數(shù)據(jù)類型，可用于與其他同類型的數(shù)據(jù)進行比較。為 Array 類型添加 equals 函數(shù)使其成為 Setoid：

Array.prototype.equals = (arr) => {
    const len = this.length
    if (len !== arr.length) {
        return false
    }
    for (let i = 0; i < len; i++) {
        if (this[i] !== arr[i]) {
            return false
        }
    }
    return true
}
[1, 2].equals([1, 2])
// => true
[1, 2].equals([0])
// => false

Semigroup，擁有 concat 函數(shù)的數(shù)據(jù)類型，可以與同類型數(shù)據(jù)進行合并：

[1].concat([2])
// => [1, 2]

Foldable，擁有 reduce 函數(shù)的數(shù)據(jù)類型，可以將 Foldable 的實例轉(zhuǎn)換為其他數(shù)據(jù)類型：

const sum = (list) => list.reduce((acc, val) => acc + val, 0);
sum([1, 2, 3]) 
// => 6