日本综合一区二区|亚洲中文天堂综合|日韩欧美自拍一区|男女精品天堂一区|欧美自拍第6页亚洲成人精品一区|亚洲黄色天堂一区二区成人|超碰91偷拍第一页|日韩av夜夜嗨中文字幕|久久蜜综合视频官网|精美人妻一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側工具欄

新聞中心

這里有您想知道的互聯網營銷解決方案
函數式編程術語解析

Arity

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

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

Higher-Order Functions

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

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

Partial Application

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

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

Currying

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

 
 
      
  
  1. const sum = (a, b) => a + b; 
    2.   
  
  2. sum(2, 3); 
    3.   
  
  3. // => 6 
    4.   
  
  4. const curriedSum = (a) => (b) => a + b; 
    5.   
  
  5. curriedSum(40)(2); 
    6.   
  
  6. // => 42. 
    7.   
  
  7. const add2 = curriedSum(2); 
    8.   
  
  8. // (b) => 2 + b 
    9.   
  
  9. add2(10); 
    10.   
  
  10. // => 12  
    11.

Function Composition

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

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

Purity

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

 
 
      
  
  1. const greet = (name) => "Hi, " + name ; 
    2.   
  
  2. greet("Brianne") 
    3.   
  
  3. // => "Hi, Brianne"  
    4.

Side effects

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

 
 
      
  
  1. let greeting; 
    2.   
  
  2. const greet = () => greeting = "Hi, " + window.name; 
    3.   
  
  3. // greet() 執(zhí)行時更改了外部環(huán)境的變量 
    4.   
  
  4. greet(); 
    5.   
  
  5. // => "Hi, Brianne" 
    6.   
  
  6. // new Date() 是可變數據 
    7.   
  
  7. const differentEveryTime = new Date();  
    8.

Point-Free Style

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

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

Predicate

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

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

Constant

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

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

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

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

Functor

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

 
 
      
  
  1. object.map(x => x) === object; 
    2.   
  
  2.  
    3.   
  
  3. object.map(x => f(g(x))) === object.map(g).map(f);  
    4.

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

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

Lift

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

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

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

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

分享題目：函數式編程術語解析
標題URL：http://www.dlmjj.cn/article/dhgohei.html