[[174906]]

Arity

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

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

Higher-Order Functions

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

const filter = (predFunc, list) => { 
  const results = []; 
  list.forEach((listItem) => { 
    if (predFunc(listItem)) { 
      results.push(listItem); 
    } 
  }); 
  return results; 
} 
// filter 這個函數就是將一個函數作為參數傳入 
// 但這都么有什么，主要是后面is函數返回一個函數 
 
const is = (type) => (x) => Object(x) instanceof type; 
// is這個函數就是將一個函數作為返回值返回到下面的調用之中 
 
filter(is(Number), [0, '1', 2, null]); 
// 上面函數調用的結果是 [0, 2]  

Partial Application

偏函數，在原函數的基礎上預填充(pre-filling)部分參數并返回的新函數：

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

Currying

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

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  

Function Composition

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

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

Purity

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

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

Side effects

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

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

Point-Free Style

point-free style 是一種不顯式向函數傳遞參數的代碼風格，通常需要柯里化和高階函數來實現：

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

Predicate

斷言，一個返回布爾值的函數：

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

Constant

常量，初始化后不能再次執行賦值操作的數據類型：

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

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

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

Functor

functor 都擁有 map 函數，并且在執行 map 之后會返回一個新的 functor:

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

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

[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

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

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 一個單參數的函數非常類似于 map 操作：

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