这是什么功能模式？ 如果有的话

Question

我发现自己一遍又一遍地写这样的代码，并且在思考。 必须有一个已知的模式，但是要仔细研究Ramda等不同功能库的文档。 我找不到比赛。 我应该使用什么？

var arrayOfPersons = [{ firstName: 'Jesper', lastName: 'Jensen', income: 120000, member: true }/* .... a hole lot of persons */];

function createPredicateBuilder(config) {

  return {

    build() {
      var fnPredicate = (p) => true;

      if (typeof config.minIncome == 'number') {
        fnPredicate = (p) => fnPredicate(p) && config.minIncome <= p.income;
      }
      if (typeof config.member == 'boolean') {
        fnPredicate = (p) => fnPredicate(p) && config.member === p.member;
      }
      // .. continue to support more predicateparts.
    },

    map(newConfig) {
      return createPredicateBuilder({ ...config, ...newConfig });
    }
  };
}

var predicateBuilder = createPredicateBuilder({});

// We collect predicates
predicateBuilder = predicateBuilder.map({ minIncome: 200000 });
// ...
predicateBuilder = predicateBuilder.map({ member: false });

// Now we want to query...
console.log(arrayOfPersons.filter(predicateBuilder.build()));

我创建一个构建器实例，并调用map，创建一个新实例，并使用build / map方法返回一个对象。 状态在功能范围中捕获。 将来的某个时候，我想获取我收集的函数（或结果）。

我认为这是FP，但是这种模式是什么，是否有任何库使它更容易？

我的灵感源自事物（构建者/构建者）的命名，这使我感到困惑吗？

Answer 1

您可以使用Ramda中的where函数来测试描述谓词的spec对象。 然后，您的代码可以根据传递的配置动态构建spec对象。

https://ramdajs.com/docs/#where

Ramda文档中的示例：

// pred :: Object -> Boolean
const pred = R.where({
  a: R.equals('foo'),
  b: R.complement(R.equals('bar')),
  x: R.gt(R.__, 10),
  y: R.lt(R.__, 20)
});

pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true
pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false
pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false
pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false
pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false

详细地说，您可以通过具有一组函数来“构建” spec对象，这些函数可以返回带有附加谓词的新spec，例如：

function setMinIncome(oldSpec, minIncome) {
  return R.merge(oldSpec, {income: R.gt(R.__, minIncome)})
}

Answer 2

这是Builder设计模式 。 尽管它在一种更实用的方法中进行了更改，但前提保持不变-您拥有一个实体，该实体通过.map()收集信息（更传统的是，它是与setter对应的.withX() ）并执行所有收集的数据以产生一个新对象.build() 。

为了使这一点更易于识别，下面是一种更加面向对象的方法，该方法仍然可以执行相同的操作：

 class Person { constructor(firstName, lastName, age) { this.firstName = firstName; this.lastName = lastName; this.age = age; } toString() { return `I am ${this.firstName} ${this.lastName} and I am ${this.age} years old`; } } class PersonBuilder { withFirstName(firstName) { this.firstName = firstName; return this; } withLastName(lastName) { this.lastName = lastName; return this; } withAge(age) { this.age = age; return this; } build() { return new Person(this.firstName, this.lastName, this.age); } } //make builder const builder = new PersonBuilder(); //collect data for the object construction builder .withFirstName("Fred") .withLastName("Bloggs") .withAge(42); //build the object with the collected data const person = builder.build(); console.log(person.toString()) 

Answer 3

函数式编程与模式无关，而与法律有关。 法律使程序员可以像数学家可以对方程式那样对程序进行推理。

让我们看一下加数。 加法是一个二进制运算 （它需要两个数字），并且总是产生另一个数字。

1 + 2 = 3
2 +1 = 3

1 +（2 + 3）= 6
（1 + 2）+ 3 = 6

（（1 + 2）+ 3）+ 4 = 10
（1 + 2）+（3 + 4）= 10
1 +（2 + 3）+ 4 = 10
1 +（2 +（3 + 4））= 10

我们可以按任意顺序添加数字，但仍然得到相同的结果。 该属性是关联性 ，它构成了关联律的基础。

加零有点有趣，或者是理所当然的。

1 + 0 = 1
0 +1 = 1

3 + 0 = 3
0 + 3 = 3

在任何数字上加零将不会更改数字。 这称为标识元素 。

---

（ 1 ）关联二进制运算和（ 2 ）标识元素这两个要素组成一个monoid 。

如果我们可以 ...

1. 将谓词编码为域的元素
2. 为元素创建二进制操作
3. 确定身份元素

...然后，我们得到属于monoid类别的好处，使我们能够以等式方式对程序进行推理。 没有学习的模式，只有遵守的法律。

---

1.建立域名

正确处理数据非常棘手，在像JavaScript这样的多范式语言中更是如此。 这个问题是关于函数式编程的，尽管函数是一个不错的选择。

在您的程序中...

build() {
  var fnPredicate = (p) => true;

  if (typeof config.minIncome == 'number') {
    fnPredicate = (p) => fnPredicate(p) && config.minIncome <= p.income;
  }
  if (typeof config.member == 'boolean') {
    fnPredicate = (p) => fnPredicate(p) && config.member === p.member;
  }
  // .. continue to support more predicateparts.
},

...我们看到了程序级别和数据级别的混合。 该程序经过硬编码，只能理解可能具有这些特定键（ minIncome ， member ）及其各自类型（ number和boolean ）的输入，以及用于确定谓词的比较操作。

让我们保持非常简单。 让我们采取一个静态谓词

item.name === "Sally"

如果我想要相同的谓词，但使用不同的项目进行比较，则可以将此表达式包装在函数中，并使item成为函数的参数。

 const nameIsSally = item => item.name === "Sally" console .log ( nameIsSally ({ name: "Alice" }) // false , nameIsSally ({ name: "Sally" }) // true , nameIsSally ({ name: "NotSally" }) // false , nameIsSally ({}) // false ) 

该谓词易于使用，但仅可用于检查名称Sally 。 我们通过将表达式包装在函数中并name函数的参数来重复该过程。 这种通用技术称为抽象，并且一直在函数式编程中使用。

 const nameIs = name => item => item.name === name const nameIsSally = nameIs ("Sally") const nameIsAlice = nameIs ("Alice") console .log ( nameIsSally ({ name: "Alice" }) // false , nameIsSally ({ name: "Sally" }) // true , nameIsAlice ({ name: "Alice" }) // true , nameIsAlice ({ name: "Sally" }) // false ) 

如您所见，我们包装的表达式已经是一个函数并不重要。 JavaScript具有对函数的一流支持，这意味着可以将它们视为值。 返回一个函数或接收一个函数作为输入的程序称为高阶函数 。

上面，我们的谓词被表示为采用任何类型（ a ）的值并产生布尔值的函数。 我们将其表示为a -> Boolean 。 因此，每个谓词都是我们域的元素，并且该域都是a -> Boolean函数。

---

2.二进制运算

我们将再进行一次抽象练习。 让我们采用静态组合谓词表达式。

p1 (item) && p2 (item)

通过将其包装在函数中并将item作为函数的参数，我可以将该表达式重新用于其他项。

const bothPredicates = item =>
  p1 (item) && p2 (item)

但是我们希望能够合并任何谓词。 同样，我们将要重用的表达式包装在函数中，然后为变量分配参数，这一次是p1和p2 。

const and = (p1, p2) => item =>
  p1 (item) && p2 (item)

在我们继续之前，让我们检查我们的域名，并确保我们的二进制运算and是正确的。 二进制操作必须：

1. 从我们的域中以两（2）个元素作为输入（ a -> Boolean ）
2. 作为输出返回我们域的元素
3. 该操作必须是关联的： f（a，b） == f（b，a）

确实， and接受域p1和p2两个元素。 返回值为item => ... ，这是一个接收item并返回p1 (item) && p2 (item)的函数。 每个谓词均接受单个值并返回布尔值。 这简化为Boolean && Boolean ，我们知道这是另一个布尔。 总结起来， and接受两个谓词并返回一个新的谓词，这正是二进制运算必须执行的操作。

 const and = (p1, p2) => item => p1 (item) && p2 (item) const nameIs = x => item => item.name === x const minIncome = x => item => x <= item.income const query = and ( nameIs ("Alice") , minIncome (5) ) console .log ( query ({ name: "Sally", income: 3}) // false , query ({ name: "Alice", income: 3 }) // false , query ({ name: "Alice", income: 7 }) // true ) 

---

3.身份元素

标识元素添加到任何其他元素后，不得更改该元素。 因此，对于任何谓词p和谓词身份元素为empty ，必须满足以下条件

和（p，空）== p
和（空，p）== p

我们可以将空谓词表示为接受任何元素并始终返回true的函数。

 const and = (p1, p2) => item => p1 (item) && p2 (item) const empty = item => true const p = x => x > 5 console .log ( and (p, empty) (3) === p (3) // true , and (empty, p) (3) === p (3) // true ) 

---

法律的力量

现在我们有了一个二进制运算和一个identity元素，我们可以组合任意数量的谓词。 我们定义了sum ，它将我们的monoid直接插入reduce 。

 // --- predicate monoid --- const and = (p1, p2) => item => p1 (item) && p2 (item) const empty = item => true const sum = (...predicates) => predicates .reduce (and, empty) // [1,2,3,4] .reduce (add, 0) // --- individual predicates --- const nameIs = x => item => item.name === x const minIncome = x => item => x <= item.income const isTeenager = item => item.age > 12 && item.age < 20 // --- demo --- const query = sum ( nameIs ("Alice") , minIncome (5) , isTeenager ) console .log ( query ({ name: "Sally", income: 8, age: 14 }) // false , query ({ name: "Alice", income: 3, age: 21 }) // false , query ({ name: "Alice", income: 7, age: 29 }) // false , query ({ name: "Alice", income: 9, age: 17 }) // true ) 

空总和谓词仍返回有效结果。 这就像匹配所有结果的空查询。

const query =
  sum ()

console .log
  ( query ({ foo: "bar" })                          // true
  )

---

免费便利

使用函数对谓词进行编码也使它们在其他方面也很有用。 如果您有一组项目，则可以直接在.find或.filter使用谓词p 。 当然，对于使用and和sum创建的谓词也是如此。

const p =
  sum (pred1, pred2, pred3, ...)

const items =
  [ { name: "Alice" ... }
  , { name: "Sally" ... }
  ]

const firstMatch =
  items .find (p)

const allMatches =
  items .filter (p)

---

使其成为一个模块

您不想定义诸如add和sum和empty全局变量。 打包此代码时，请使用某种模块。

// Predicate.js
const add = ...

const empty = ...

const sum = ...

const Predicate =
  { add, empty, sum }

export default Predicate

使用时

import { sum } from './Predicate'

const query =
  sum (...)

const result =
  arrayOfPersons .filter (query)

---

测验

注意我们的谓词身份元素和&&的身份元素之间的相似性

T &&？ == T
？ && T == T
F ＆＆ ？ == F
？ && F == F

我们可以代替所有? 上面带有T的等式将成立。 在下面，您认为Identity元素用于||是什么？ ？

T || ？ == T
？ || T == T
F || ？ == F
？ || F == F

*二进制乘法的标识元素是什么？

n *？ = n
？ * n = n

数组或列表的标识元素如何？

concat（l，？）== l
concat（？，l）== l

---

正玩得开心？

我想您会喜欢互变函子 。 在同一个舞台上， 换能器 。 有一个演示演示了如何围绕这些低级模块构建高级API。

Answer 4

我会坚持一个简单的（组成）谓词函数数组和一个归约函数

• And （ f => g => x => f(x) && g(x) ），种子为True （ _ => true ）。
• Or （ f => g => x => f(x) || g(x) ），种子为False （ _ => false ）。

例如：

 const True = _ => true; const False = _ => false; const Or = (f, g) => x => f(x) || g(x); Or.seed = False; const And = (f, g) => x => f(x) && g(x); And.seed = True; const Filter = (fs, operator) => fs.reduce(operator, operator.seed); const oneOrTwo = Filter([x => x === 1, x => x === 2], Or); const evenAndBelowTen = Filter([x => x % 2 === 0, x => x < 10], And); const oneToHundred = Array.from(Array(100), (_, i) => i); console.log( "One or two", oneToHundred.filter(oneOrTwo), "Even and below 10", oneToHundred.filter(evenAndBelowTen) ); 

您甚至可以通过嵌套“ And / Or结构来创建复杂的过滤器逻辑：

 const True = _ => true; const False = _ => false; const Or = (f, g) => x => f(x) || g(x); Or.seed = False; const And = (f, g) => x => f(x) && g(x); And.seed = True; const Filter = (fs, operator) => fs.reduce(operator, operator.seed); const mod = x => y => y % x === 0; const oneToHundred = Array.from(Array(100), (_, i) => i); console.log( "Divisible by (3 and 5), or (3 and 7)", oneToHundred.filter( Filter( [ Filter([mod(3), mod(5)], And), Filter([mod(3), mod(7)], And) ], Or ) ) ); 

或者，以您自己的示例情况：

 const comp = (f, g) => x => f(g(x)); const gt = x => y => y > x; const eq = x => y => x === y; const prop = k => o => o[k]; const And = (f, g) => x => f(x) && g(x); const True = _ => true; const Filter = (fs) => fs.reduce(And, True); const richMemberFilter = Filter( [ comp(gt(200000), prop("income")), comp(eq(true), prop("member")) ] ); console.log( "Rich members:", data().filter(richMemberFilter).map(prop("firstName")) ); function data() { return [ { firstName: 'Jesper', lastName: 'Jensen', income: 120000, member: true }, { firstName: 'Jane', lastName: 'Johnson', income: 230000, member: true }, { firstName: 'John', lastName: 'Jackson', income: 230000, member: false } ]; };