函数式编程术语解析

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]

网站栏目：函数式编程术语解析
链接URL：http://www.csdahua.cn/qtweb/news6/388356.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：快上网

成都快上网为您推荐相关内容