跳转至

Ramda 教程

原文： http://zetcode.com/javascript/ramda/

Ramda 教程展示了如何使用 Ramda 库，该库为 JavaScript 中的高级函数编程提供了工具。 在本教程中，我们可以互换使用术语列表和数组。

Ramda

Ramda 是 JavaScript 程序员的实用函数库。 该库专注于不变性和无副作用的函数。 Ramda 函数也会自动进行更新，从而只需不提供最终参数就可以从旧函数中构建新函数。

在本教程中，我们在 Node 应用中使用 Ramda。

安装 Ramda

首先，我们安装 Ramda。

$ nodejs -v
v9.11.2

我们使用 Node 版本 9.11.2。

$ npm init

我们启动一个新的 Node 应用。

$ npm i ramda

我们使用npm i ramda命令安装 Ramda。

const R = require('ramda');

按照惯例，该库使用 R 字母。

Ramda add()，subtract()函数

add()函数将两个值相加，subtract()函数将两个值相减。

add_sub.js

const R = require('ramda');

console.log(R.add(2, 5));
console.log(R.subtract(2, 5));

let res = R.add(R.add(2, 5), R.subtract(2, 10));
console.log(res);

该示例同时使用add()和subtract()函数。

let res = R.add(R.add(2, 5), R.subtract(2, 10));

在这里，我们结合了这些函数。

$ node add_sub.js
7
-3
-1

这是输出。

Ramda flip()函数

flip()函数从提供的函数返回一个新函数，该函数的参数相反。

flipfun.js

const R = require('ramda');

let val = R.subtract(2, 10);
console.log(val);

let val2 = R.flip(R.subtract)(2, 10);
console.log(val2);

该示例使用flip()反转subtract()函数的参数。

$ node flipfun.js
-8
8

这是输出。

Ramda call()函数

call()函数在用逗号分隔的参数上调用提供的函数。

calling.js

const R = require('ramda');

let res = R.call(R.add, 1, 2);
console.log(res);

console.log(R.call(R.repeat, 'x')(5));

R.call(console.log, [1, 2, 3]);

该示例使用call()函数。

let res = R.call(R.add, 1, 2);

我们调用add()函数将两个整数相加。

console.log(R.call(R.repeat, 'x')(5));

我们调用repeat()函数来生成五个"x"字母的列表。

R.call(console.log, [1, 2, 3]);

最后，我们使用call()函数输出列表。

$ node calling.js
3
[ 'x', 'x', 'x', 'x', 'x' ]
[ 1, 2, 3 ]

这是输出。

Ramda apply()函数

apply()函数在参数列表上调用提供的函数。

applyfun.js

const R = require('ramda');

let nums = [3, 5, 7, 8, 2, 1];

let res = R.apply(Math.min, nums);
console.log(res);

let res2 = R.apply(Math.max, nums);
console.log(res2);

该示例使用apply()函数来计算最小值和最大值。

let res = R.apply(Math.min, nums);

我们在nums列表上调用Math.min函数。 我们从这些值中获得最小值。

$ node applyfun.js
1
8

我们得到最小和最大。

Ramda 自动柯里

柯里化是将需要多个参数的函数转换为另一个函数的过程，当提供较少的参数时，该函数将返回一个等待其余参数的新函数。

currying.js

const R = require('ramda');

let addOneToAll = R.map(R.add(1));
let res = addOneToAll([1,2,3]);

console.log(res);

在示例中，我们创建了一个addOneToAll()函数，该函数将列表中的每个元素加 1。

$ node currying.js 
[ 2, 3, 4 ]

这是输出。

Ramda head()，tail()，init()，last()函数

head()返回给定列表或字符串的第一个元素。 tail()返回给定列表或字符串的除第一个元素外的所有元素。 init()返回给定列表或字符串的最后一个元素以外的所有元素。 last()返回给定列表或字符串的最后一个元素。

head_tail.js

const R = require('ramda');

let nums = [2, 4, 6, 8, 10];

console.log(R.head(nums));
console.log(R.tail(nums));
console.log(R.init(nums));
console.log(R.last(nums));

该示例在值数组上使用head()，tail()，init()和last()函数。

$ node head_tail.js
2
[ 4, 6, 8, 10 ]
[ 2, 4, 6, 8 ]
10

这是输出。

Ramda length()函数

length()函数返回列表中的元素数。

lengthfun.js

const R = require('ramda');

let nums = [1, 2, 2, 2, 3, 3, 4, 5, 5, 5, 6, 7];

let n1 = R.length(nums);
console.log(n1);

let n2 = R.length(R.uniq(nums));
console.log(n2);

在示例中，我们计算列表中的元素数和列表中的唯一元素数。

$ node lengthfn.js
12
7

列表中有十二个元素，列表中有七个唯一元素。

Ramda prop()函数

prop()函数返回对象的指定属性（如果存在）。

propfun.js

const R = require('ramda');

console.log(R.prop('name', { name: 'John', age: 25 }));
console.log(R.prop('age', { name: 'John', age: 25 }));

使用prop()函数，我们可以获得name和age属性的值。

$ node propfun.js
John
25

这是输出。

Ramda pluck()函数

pluck()函数通过从提供的列表中的所有对象上拔出指定的属性来返回新列表。

plucking.js

const R = require('ramda');

const users = [
  { name: 'John', age: 25 },
  { name: 'Lenny', age: 51 },
  { name: 'Andrew', age: 43 },
  { name: 'Peter', age: 81 },
  { name: 'Anna', age: 43 },
  { name: 'Albert', age: 76 },
  { name: 'Adam', age: 47 },
  { name: 'Robert', age: 72 }
];

console.log(R.pluck('age', users));
console.log(R.pluck('name', users));

通过pluck()函数，我们获得name和age属性，并形成两个新列表。

$ node plucking.js
[ 25, 51, 43, 81, 43, 76, 47, 72 ]
[ 'John',
  'Lenny',
  'Andrew',
  'Peter',
  'Anna',
  'Albert',
  'Adam',
  'Robert' ]

在下面的示例中，我们将使用形成的列表。

plucking2.js

const R = require('ramda');

const users = [
  { name: 'John', age: 25 },
  { name: 'Lenny', age: 51 },
  { name: 'Andrew', age: 43 },
  { name: 'Peter', age: 81 },
  { name: 'Anna', age: 43 },
  { name: 'Albert', age: 76 },
  { name: 'Adam', age: 47 },
  { name: 'Robert', age: 72 }
];

let maxAge = R.apply(Math.max, R.pluck('age', users));
// let maxAge = Math.max(... R.pluck('age', users));

console.log(`The oldest person is ${maxAge} years old.`);

在示例中，我们找出一个人的最大年龄。

let maxAge = R.apply(Math.max, R.pluck('age', users));

通过在年龄列表上调用Math.max()函数，我们可以获得最老的年龄。

// let maxAge = Math.max(... R.pluck('age', users));

另一种带注释的解决方案使用扩展运算符代替apply()函数。

$ node plucking2.js
The oldest person is 81 years old.

这是输出。

Ramda 拆分列表

使用splitEvery()函数，我们可以将列表分成指定长度的块。

chunks.js

const R = require('ramda');

let nums = [1, 2, 3, 4, 5, 6];

console.log(R.splitEvery(2, nums));
console.log(R.splitEvery(3, nums));

在示例中，我们将数组分为 2 个元素和 3 个元素的块。

$ node chunks.js
[ [ 1, 2 ], [ 3, 4 ], [ 5, 6 ] ]
[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]

这是输出。

Ramda contains()函数

如果指定的值在列表中，则contains()函数返回true。

containsfun.js

const R = require('ramda');

const users = [
  { name: 'John', age: 25 },
  { name: 'Lenny', age: 51 },
  { name: 'Andrew', age: 43 },
  { name: 'Peter', age: 81 },
  { name: 'Anna', age: 43 },
  { name: 'Albert', age: 76 },
  { name: 'Adam', age: 47 },
  { name: 'Robert', age: 72 }
];

let isJohn = R.contains('John', R.pluck('name', users));

if (isJohn) {

  console.log('There is John in the list');
}

在示例中，我们检查指定的用户是否在列表中。

let isJohn = R.contains('John', R.pluck('name', users));

首先，我们使用pluck()函数从name属性中形成一个列表。 然后我们用contains()检查'John'是否在列表中。

$ node containsfun.js
There is John in the list

这是输出。

Ramda range()函数

range()函数返回从起始值（包含）到结束值（不含）的数字列表。

rangefun.js

const R = require('ramda');

console.log(R.range(1, 10));

let vals = R.range(2, 12);

vals.forEach(x => console.log(x));

该示例显示了如何使用range()函数。

console.log(R.range(1, 10));

在这一行中，我们创建一个1..9整数列表。 我们将它们打印到控制台。

let vals = R.range(2, 12);

vals.forEach(x => console.log(x));

在这里，我们生成一个2..11值的列表。 我们使用forEach()函数浏览列表。

$ node rangefun.js
[ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
2
3
4
5
6
7
8
9
10
11

这是输出。

Ramda sum()函数

sum()函数对列表的所有元素求和。

summation.js

const R = require('ramda');

let nums = [2, 4, 6, 8, 10];
console.log(R.sum(nums));

console.log(R.sum(R.range(1, 11)));

该示例使用sum()函数对整数值求和。

let nums = [2, 4, 6, 8, 10];
console.log(R.sum(nums));

在这里，我们对nums数组的值求和。

console.log(R.sum(R.range(1, 11)));

在这一行中，我们对range()函数生成的列表的值求和。

$ node summation.js
30
55

这是输出。

Ramda product()函数

product()函数将列表的所有元素相乘。

productfun.js

const R = require('ramda');

let nums = [2, 4, 6, 8, 10];

console.log(R.product(nums));

该示例计算整数列表的乘积。

$ node productfun.js
3840

这是输出。

Ramda sort()，reverse()函数

sort()函数返回列表的副本，该列表根据比较器函数排序。 比较器函数一次接受两个值，如果第一个值较小，则返回一个负数；如果较大，则返回一个正数；如果相等，则返回零。

reverse()函数以相反的顺序返回带有元素或字符的新列表或字符串。

sort_reverse.js

const R = require('ramda');

let nums = [3, 1, 4, 2, 8, 5, 6];

console.log('sorting:')

// sort ascending
console.log(R.sort((x, y) =>  x - y , nums));

// sort descending
console.log(R.sort((x, y) =>  y - x , nums));

console.log('reversing:')

// reversing
console.log(R.reverse(nums));
console.log(R.reverse('forest'));

该示例按升序和降序对整数进行排序，并反转整数和字符串。

$ node sort_reverse.js
sorting:
[ 1, 2, 3, 4, 5, 6, 8 ]
[ 8, 6, 5, 4, 3, 2, 1 ]
reversing:
[ 6, 5, 8, 2, 4, 1, 3 ]
tserof

这是输出。

我们还可以使用内置的R.lt和R.gt比较器。

sort_comp.js

const R = require('ramda');

let nums = [3, 1, 4, 2, 8, 5, 6];

console.log('sorting:')

// sort ascending
console.log(R.sort(R.comparator(R.lt), nums));

// sort descending
console.log(R.sort(R.comparator(R.gt), nums));

该示例按升序和降序对整数进行排序。

Ramda sortBy函数

sortBy()函数根据提供的函数对列表进行排序。

sorting_objects.js

const R = require('ramda');

const users = [
  { name: 'John', age: 25 },
  { name: 'Lenny', age: 51 },
  { name: 'Andrew', age: 43 },
  { name: 'Peter', age: 81 },
  { name: 'Anna', age: 43 },
  { name: 'Albert', age: 76 },
  { name: 'Adam', age: 47 },
  { name: 'Robert', age: 72 }
];

console.log('Sorted by age:');

let sortedByAge = R.sortBy(R.prop('age'), users);
console.log(sortedByAge);

console.log('Sorted by name:');

let sortedByName = R.sortBy(R.prop('name'), users);
console.log(sortedByName);

在示例中，我们按age和name属性以升序对用户列表进行排序。

$ node sorting_objects.js
Sorted by age:
[ { name: 'John', age: 25 },
  { name: 'Andrew', age: 43 },
  { name: 'Anna', age: 43 },
  { name: 'Adam', age: 47 },
  { name: 'Lenny', age: 51 },
  { name: 'Robert', age: 72 },
  { name: 'Albert', age: 76 },
  { name: 'Peter', age: 81 } ]
Sorted by name:
[ { name: 'Adam', age: 47 },
  { name: 'Albert', age: 76 },
  { name: 'Andrew', age: 43 },
  { name: 'Anna', age: 43 },
  { name: 'John', age: 25 },
  { name: 'Lenny', age: 51 },
  { name: 'Peter', age: 81 },
  { name: 'Robert', age: 72 } ]

这是输出。

Ramda find，findLast函数

find()函数返回与谓词匹配的列表的第一个元素；如果不匹配，则返回undefined。 findLast()函数返回列表中与谓词匹配的最后一个元素，如果没有元素匹配，则返回undefined。

finding.js

const R = require('ramda');

const isPositive = x => x > 0;

let values = [-1, 0, -4, 5, 6, -1, 9, -2]

let val = R.find(isPositive, values);
console.log(val);

let val2 = R.findLast(isPositive, values);
console.log(val2);

在示例中，我们找到第一个和最后一个正值。

const isPositive = x => x > 0;

isPositive()是一个谓词函数，对于大于零的值返回true。

let val = R.find(isPositive, values);

使用find()，我们发现第一个出现的正数。

let val2 = R.findLast(isPositive, values);

使用findLast()，我们找到最后一个正数。

$ node finding.js
5
9

第一个正值为 5，最后为 9。

在下面的示例中，我们在对象列表上使用find()函数。

finding2.js

const R = require('ramda');

const users = [
  { name: 'John', age: 25 },
  { name: 'Lenny', age: 51 },
  { name: 'Andrew', age: 43 },
  { name: 'Peter', age: 81 },
  { name: 'Anna', age: 43 },
  { name: 'Albert', age: 76 },
  { name: 'Adam', age: 47 },
  { name: 'Robert', age: 72 }, 
  { name: 'Robert', age: 26 }, 
];

console.log(R.find(R.propEq('name', 'Robert'))(users));
console.log(R.find(R.propEq('age', 81))(users));

通过find()和propEq()函数的组合，我们寻找具有指定属性的用户。

console.log(R.find(R.propEq('name', 'Robert'))(users));

在这里，我们寻找一个名叫罗伯特的人。 有两个罗伯茨（Roberts），并且第一场比赛被返回。

$ node finding2.js
{ name: 'Robert', age: 72 }
{ name: 'Peter', age: 81 }

这是输出。

Ramda map()函数

map()函数将提供的函数映射到每个容器的值。

mapping.js

const R = require('ramda');

nums = [2, 4, 5, 6, 7, 8, 9];

let res = R.map(x => x * 2, nums);
console.log(res);

const isEven = x => x % 2 === 0;
let res2 = R.map(isEven, nums);
console.log(res2);

let repeated = R.map(R.call, R.repeat(Math.random, 5));
console.log(repeated);

该示例演示了map()的用法。

let res = R.map(x => x * 2, nums);

我们将匿名函数映射到整数列表上。 生成一个新列表，其中每个值都乘以 2。

const isEven = x => x % 2 === 0;
let res2 = R.map(isEven, nums);

在这里，我们在每个元素上应用isEven()函数。 res2是正确和错误值的列表。 如果我们只想选择事件号，则可以使用filter()函数。

let repeated = R.map(R.call, R.repeat(Math.random, 5));

在第三种情况下，我们生成五个随机值的列表。

$ node mapping.js
[ 4, 8, 10, 12, 14, 16, 18 ]
[ true, true, false, true, false, true, false ]
[ 0.22019193556521865,
  0.415950206671615,
  0.8770997167119405,
  0.23393806619678315,
  0.8181008680173825 ]

这是输出。

Ramda filter()函数

filter()函数根据提供的谓词函数过滤可过滤对象（例如列表或普通对象）。 （谓词是一个返回布尔值的函数）。

filtering.js

const R = require('ramda');

nums = [-3, -1, 0, 2, 3, 4, 5, 6, 7]

let res = R.filter(x => x > 0, nums);
console.log(res);

let res2 = R.filter(x => x < 0, nums);
console.log(res2);

const isEven = x => x % 2 === 0;

let filtered = R.filter(isEven, nums); 
console.log(filtered);

在示例中，我们有一个整数值列表。 我们使用filter()函数过滤出正，负和偶数值。

let res = R.filter(x => x > 0, nums);

此行中的filter()函数采用匿名函数，该函数对于所有大于零的值都返回true。 然后将谓词应用于列表的每个元素。 这样，我们形成一个仅包含正值的新列表。

$ node filtering.js
[ 2, 3, 4, 5, 6, 7 ]
[ -3, -1 ]
[ 0, 2, 4, 6 ]

这是输出。

在下面的示例中，我们将filter()函数应用于用户列表。

filtering2.js

const R = require('ramda');

// senior is a person who is 70+

const users = [
  { name: 'John', age: 25 },
  { name: 'Lenny', age: 51 },
  { name: 'Andrew', age: 43 },
  { name: 'Peter', age: 81 },
  { name: 'Anna', age: 43 },
  { name: 'Albert', age: 76 },
  { name: 'Adam', age: 47 },
  { name: 'Robert', age: 72 }
];

console.log(R.filter(user => user.age >= 70, users));

该示例将高级用户过滤掉。 我们将年长者定义为 70 岁以上的人。

$ node filtering2.js
[ { name: 'Peter', age: 81 },
  { name: 'Albert', age: 76 },
  { name: 'Robert', age: 72 } ]

我们有三个高级用户。

reject()函数

reject()是filter()的补充。 它排除谓词为其返回true的可过滤元素。

rejecting.js

const R = require('ramda');

const users = [
    { name: 'John', city: 'London', born: '2001-04-01' },
    { name: 'Lenny', city: 'New York', born: '1997-12-11' },
    { name: 'Andrew', city: 'Boston', born: '1987-02-22' },
    { name: 'Peter', city: 'Prague', born: '1936-03-24' },
    { name: 'Anna', city: 'Bratislava', born: '1973-11-12' },
    { name: 'Albert', city: 'Bratislava', born: '1940-18-19' },
    { name: 'Adam', city: 'Trnava', born:'1983-12-01' },
    { name: 'Robert', city: 'Bratislava', born: '1935-05-15' }, 
    { name: 'Robert', city: 'Prague', born:'1998-03-14' }
  ];

let res = R.reject(R.propEq('city', 'Bratislava'))(users);
console.log(res);

let res2 = R.filter(R.propEq('city', 'Bratislava'))(users);
console.log(res2);

在示例中，我们使用reject()函数形成不包含布拉迪斯拉发城市的对象的新列表。 我们还使用filter()函数形成包含布拉迪斯拉发城市的对象的新列表。

$ node rejecting.js
[ { name: 'John', city: 'London', born: '2001-04-01' },
  { name: 'Lenny', city: 'New York', born: '1997-12-11' },
  { name: 'Andrew', city: 'Boston', born: '1987-02-22' },
  { name: 'Peter', city: 'Prague', born: '1936-03-24' },
  { name: 'Adam', city: 'Trnava', born: '1983-12-01' },
  { name: 'Robert', city: 'Prague', born: '1998-03-14' } ]
[ { name: 'Anna', city: 'Bratislava', born: '1973-11-12' },
  { name: 'Albert', city: 'Bratislava', born: '1940-18-19' },
  { name: 'Robert', city: 'Bratislava', born: '1935-05-15' } ]

这是输出。 第一个列表包含不包含布拉迪斯拉发城市属性的所有对象。第二个列表仅包含具有布拉迪斯拉发城市属性的对象。

partition()函数

partition()函数将filter分为两个独立的对象：一个满足谓词，另一个不满足。

partitionfun.js

const R = require('ramda');

let nums = [4, -5, 3, 2, -1, 7, -6, 8, 9];

let [ neg, pos ] = R.partition(e => e < 0, nums);

console.log(neg);
console.log(pos);

使用partition()函数，我们将整数列表分为两个单独的列表：负数和正数。

$ node partitionfun.js
[ -5, -1, -6 ]
[ 4, 3, 2, 7, 8, 9 ]

第一个列表包含负值，第二个列表包含正值。

Ramda groupBy函数

groupBy()函数基于在每个元素上调用String返回函数并根据返回的值对结果进行分组的结果，将列表分为存储在对象中的子列表。

grouping.js

const R = require('ramda');

let students = [
  { name: 'Adam', score: 84 },
  { name: 'Eddy', score: 58 },
  { name: 'Peter', score: 69 },
  { name: 'Roman', score: 93 },
  { name: 'Jane', score: 56 },
  { name: 'Lucy', score: 76 },
  { name: 'Jack', score: 88 },
];

var groupByGrade = R.groupBy((student) => {

  let score = student.score;

  return score < 65 ? 'F' :
         score < 70 ? 'D' :
         score < 80 ? 'C' :
         score < 90 ? 'B' : 'A';
});

let grouped = groupByGrade(students);

console.log('Student(s) having A grade:');
console.log(grouped['A']);

console.log('Student(s) having B grade:');
console.log(grouped['B']);

console.log('Student(s) having C grade:');
console.log(grouped['D']);

console.log('Student(s) having D grade:');
console.log(grouped['D']);

console.log('Student(s) having F grade:');
console.log(grouped['F']);

在此示例中，我们将学生按分数分组到成绩子列表中。

$ node grouping.js
Student(s) having A grade:
[ { name: 'Roman', score: 93 } ]
Student(s) having B grade:
[ { name: 'Adam', score: 84 }, { name: 'Jack', score: 88 } ]
Student(s) having C grade:
[ { name: 'Peter', score: 69 } ]
Student(s) having D grade:
[ { name: 'Peter', score: 69 } ]
Student(s) having F grade:
[ { name: 'Eddy', score: 58 }, { name: 'Jane', score: 56 } ]

这是输出。

Ramda reduce()函数

reduce()函数将列表值聚合为一个值。 它对一个累加器和列表中的每个元素（从左到右）应用一个函数，以将其减少为单个值。

reducefun.js

const R = require('ramda');

let nums = [2, 3, 4, 5, 6, 7];

let sum = R.reduce((x, y) => x+y, 0, nums);
console.log(sum);

let product = R.reduce((x, y) => x*y, 1, nums);
console.log(product);

该示例使用reduce()函数来计算整数列表的总和。

let sum = R.reduce((x, y) => x+y, 0, nums);

在这一行中，我们计算值的总和。 第一个参数是应用于值的函数。 第二个是累加器，它是起始值。 第三是包含值的列表。

let product = R.reduce((x, y) => x*y, 1, nums);

在这里，我们计算列表值的乘积。

$ node reducefun.js 
27
5040

这是输出。

下面的示例计算表达式：1*2 + 3*4 + 5*6。

reduce_fun2.js

const R = require('ramda');

let nums = [1, 2, 3, 4, 5, 6];

let ret = R.reduce((acc, x) => acc + x[0] * x[1], 0, R.splitEvery(2, nums));
console.log(ret);

在示例中，我们将列表分成几对，并对这些对应用归约操作。

$ node reduce_fun2.js
44

这是输出。

where()函数

where()函数允许在对象上创建复杂的查询。

wherefun.js

const R = require('ramda');
const moment = require('moment');

const users = [
  { name: 'John', city: 'London', born: '2001-04-01' },
  { name: 'Lenny', city: 'New York', born: '1997-12-11' },
  { name: 'Andrew', city: 'Boston', born: '1987-02-22' },
  { name: 'Peter', city: 'Prague', born: '1936-03-24' },
  { name: 'Anna', city: 'Bratislava', born: '1973-11-18' },
  { name: 'Albert', city: 'Bratislava', born: '1940-12-11' },
  { name: 'Adam', city: 'Trnava', born: '1983-12-01' },
  { name: 'Robert', city: 'Bratislava', born: '1935-05-15' },
  { name: 'Robert', city: 'Prague', born: '1998-03-14' }
];

let res1 = R.filter(R.where({ city: R.equals('Bratislava') }))(users);
console.log(res1);

let res2 = R.filter(R.where({
  city: R.equals('Bratislava'),
  name: R.startsWith('A')
}))(users);

console.log(res2);

let res3 = R.filter(R.where({
  born: (dt) => getAge(dt) > 40}))(users);

console.log(res3);

function getAge(dt) {

    return moment.duration(moment() - moment(dt, 'YYYY-MM-DD', true)).years();
}

在示例中，我们在用户列表上使用where()创建查询。

let res1 = R.filter(R.where({ city: R.equals('Bratislava') }))(users);

在这里，我们找出居住在布拉迪斯拉发的所有用户。

let res2 = R.filter(R.where({
  city: R.equals('Bratislava'),
  name: R.startsWith('A')
}))(users);

在此代码中，我们找到了居住在布拉迪斯拉发的用户，其名称以"A"开头。

let res3 = R.filter(R.where({
  born: (dt) => getAge(dt) > 40}))(users);

最后，我们找出 40 岁以上的用户。

function getAge(dt) {

    return moment.duration(moment() - moment(dt, 'YYYY-MM-DD', true)).years();
}

要从提供的出生日期算起年龄，我们使用矩模块。

$ node where_fun.js
[ { name: 'Anna', city: 'Bratislava', born: '1973-11-18' },
  { name: 'Albert', city: 'Bratislava', born: '1940-12-11' },
  { name: 'Robert', city: 'Bratislava', born: '1935-05-15' } ]
[ { name: 'Anna', city: 'Bratislava', born: '1973-11-18' },
  { name: 'Albert', city: 'Bratislava', born: '1940-12-11' } ]
[ { name: 'Peter', city: 'Prague', born: '1936-03-24' },
  { name: 'Anna', city: 'Bratislava', born: '1973-11-18' },
  { name: 'Albert', city: 'Bratislava', born: '1940-12-11' },
  { name: 'Robert', city: 'Bratislava', born: '1935-05-15' } ]

这是输出。

在本教程中，我们使用了Ramda库。

您可能也会对以下相关教程感兴趣： Lodash 教程， Collect.js 教程， JavaScript 数组， Moment.js 教程 。

我们一直在努力

apachecn/AiLearning

【布客】中文翻译组