Ramda 函数库参考教程

2020-06-24

Ann Ann

学习函数式编程的过程中，我接触到了 Ramda.js。

我发现，这是一个很重要的库，提供了许多有用的方法，每个 JavaScript 程序员都应该掌握这个工具。

你可能会问，Underscore 和 Lodash 已经这么流行了，为什么还要学习好像雷同的 Ramda 呢？

回答是，前两者的参数位置不对，把处理的数据放到了第一个参数。

var square = n => n * n;
_.map([4, 8], square) // [16, 64]

上面代码中，_.map的第一个参数[4, 8]是要处理的数据，第二个参数square是数据要执行的运算。

Ramda 的数据一律放在最后一个参数，理念是“function first，data last”。

var R = require('ramda');
R.map(square, [4, 8]) // [16, 64]

为什么 Underscore 和 Lodash 是错的，而 Ramda 是对的？这放在下一篇文章详细解释，今天我主要介绍 Ramda 提供的几十个方法。这是理解以后的内容所必须的。

除了数据放在最后一个参数，Ramda 还有一个特点：所有方法都支持柯里化。

也就是说，所有多参数的函数，默认都可以单参数使用。

// 写法一
R.map(square, [4, 8])

// 写法二
R.map(square)([4, 8])
// 或者
var mapSquare = R.map(square);
mapSquare([4, 8]);

上面代码中，写法一是多参数版本，写法二是柯里化以后的单参数版本。Ramda 都支持，并且推荐使用第二种写法。

由于这两个特点，使得 Ramda 成为 JavaScript 函数式编程最理想的工具库。今天，我先介绍它的 API，下一次再介绍这些方法如何用于实战。我保证，一旦你理解了它的运算模型，就一定会认同这才是正确的计算方法。

下面所有的示例，都可以在线上测试环境运行。

Ramda API 介绍

一、比较运算
二、数学运算
三、逻辑运算
四、字符串
五、函数
- 5.1 函数的合成
- 5.2 柯里化
- 5.3 函数的执行
六、数组
- 6.1 数组的特征判断
- 6.2 数组的截取和添加
- 6.3 数组的过滤
- 6.4 单数组运算
- 6.5 双数组运算
- 6.6 复合数组
七、对象
- 7.1 对象的特征判断
- 7.2 对象的过滤
- 7.3 对象的截取
- 7.4 对象的运算
- 7.5 复合对象

一、比较运算

gt：判断第一个参数是否大于第二个参数。

R.gt(2)(1) // true
R.gt('a')('z') // false

gte：判断第一个参数是否大于等于第二个参数。

R.gte(2)(2) // true
R.gte('a')('z') // false

lt：判断第一个参数是否小于第二个参数。

R.lt(2)(1) // false
R.lt('a')('z') // true

lte：判断第一个参数是否小于等于第二个参数。

R.lte(2)(2) // true
R.lte('a')('z') // true

equals：比较两个值是否相等（支持对象的比较）。

R.equals(1)(1) // true
R.equals(1)('1') // false
R.equals([1, 2, 3])([1, 2, 3]) // true

var a = {}; 
a.v = a;
var b = {}; 
b.v = b;
R.equals(a)(b)
// true

eqBy：比较两个值传入指定函数的运算结果是否相等。

R.eqBy(Math.abs, 5)(-5)
// true

二、数学运算

add：返回两个值的和。

R.add(7)(10) // 17

subtract：返回第一个参数减第二个参数的差。

`R.subtract(10)(8) // 2

multiply：返回两个值的差。

R.multiply(2)(5)  // 10

divide：返回第一个参数除以第二个参数的商。

R.divide(71)(100) // 0.71

三、逻辑运算

either：接受两个函数作为参数，只要有一个返回true，就返回true，否则返回false。相当于||运算。

var gt10 = x => x > 10;
var even = x => x % 2 === 0;

var f = R.either(gt10, even);
f(101) // true
f(8) // true

both：接受两个函数作为参数，只有它们都返回true，才返回true，否则返回false，相当于&&运算。

var gt10 = x => x > 10;
var even = x => x % 2 === 0;

var f = R.both(gt10, even);
f(15) // false
f(30) // true

allPass：接受一个函数数组作为参数，只有它们都返回true，才返回true，否则返回false。

var gt10 = x => x > 10;
var even = x => x % 2 === 0;

var isEvenAndGt10 = R.allPass([gt10, even]);
isEvenAndGt10(15) // false
isEvenAndGt10(30) // true

四、字符串

split：按照指定分隔符将字符串拆成一个数组。

R.split('.')('a.b.c.xyz.d')
// ['a', 'b', 'c', 'xyz', 'd']

test：判断一个字符串是否匹配给定的正则表达式。

R.test(/^x/)('xyz')
// true

R.test(/^y/)('xyz')
// false

match：返回一个字符串的匹配结果。

R.match(/([a-z]a)/g)('bananas')
// ['ba', 'na', 'na']

R.match(/a/)('b')
// []

R.match(/a/)(null)
// TypeError: null does not have a method named "match"

五、函数

5.1 函数的合成

compose：将多个函数合并成一个函数，从右到左执行。

R.compose(Math.abs, R.add(1), R.multiply(2))(-4) // 7

pipe：将多个函数合并成一个函数，从左到右执行。

var negative = x => -1 * x;
var increaseOne = x => x + 1;

var f = R.pipe(Math.pow, negative, increaseOne);
f(3, 4) // -80 => -(3^4) + 1

converge：接受两个参数，第一个参数是函数，第二个参数是函数数组。传入的值先使用第二个参数包含的函数分别处理以后，再用第一个参数处理前一步生成的结果。

var sumOfArr = arr => {
  var sum = 0;
  arr.forEach(i => sum += i);
  return sum;
};
var lengthOfArr = arr => arr.length;

var average = R.converge(R.divide, [sumOfArr, lengthOfArr])
average([1, 2, 3, 4, 5, 6, 7])
// 4
// 相当于 28 除以 7

var toUpperCase = s => s.toUpperCase();
var toLowerCase = s => s.toLowerCase();
var strangeConcat = R.converge(R.concat, [toUpperCase, toLowerCase])
strangeConcat("Yodel")
// "YODELyodel"
// 相当于 R.concat('YODEL', 'yodel')

5.2 柯里化

curry：将多参数的函数，转换成单参数的形式。

var addFourNumbers = (a, b, c, d) => a + b + c + d;

var curriedAddFourNumbers = R.curry(addFourNumbers);
var f = curriedAddFourNumbers(1, 2);
var g = f(3);
g(4) // 10

partial：允许多参数的函数接受一个数组，指定最左边的部分参数。

var multiply2 = (a, b) => a * b;
var double = R.partial(multiply2, [2]);
double(2) // 4

var greet = (salutation, title, firstName, lastName) =>
  salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';

var sayHello = R.partial(greet, ['Hello']);
var sayHelloToMs = R.partial(sayHello, ['Ms.']);
sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'

partialRight：与partial类似，但数组指定的参数为最右边的参数。

var greet = (salutation, title, firstName, lastName) =>
  salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';

var greetMsJaneJones = R.partialRight(greet, ['Ms.', 'Jane', 'Jones']);
greetMsJaneJones('Hello') // 'Hello, Ms. Jane Jones!'

useWith：接受一个函数fn和一个函数数组fnList作为参数，返回fn的柯里化版本。该新函数的参数，先分别经过对应的fnList成员处理，再传入fn执行。

var decreaseOne = x => x - 1;
var increaseOne = x => x + 1;

R.useWith(Math.pow, [decreaseOne, increaseOne])(3, 4) // 32
R.useWith(Math.pow, [decreaseOne, increaseOne])(3)(4) // 32

memoize：返回一个函数，会缓存每一次的运行结果。

var productOfArr = arr => {
  var product = 1;
  arr.forEach(i => product *= i);
  return product;
};
var count = 0;
var factorial = R.memoize(n => {
  count += 1;
  return productOfArr(R.range(1, n + 1));
});
factorial(5) // 120
factorial(5) // 120
factorial(5) // 120
count // 1

complement：返回一个新函数，如果原函数返回true，该函数返回false；如果原函数返回false，该函数返回true。

var gt10 = x => x > 10;
var lte10 = R.complement(gt10);
gt10(7) // false
lte10(7) // true

5.3 函数的执行

binary：参数函数执行时，只传入最前面两个参数。

var takesThreeArgs = function(a, b, c) {
  return [a, b, c];
};

var takesTwoArgs = R.binary(takesThreeArgs);
takesTwoArgs(1, 2, 3) // [1, 2, undefined]

tap：将一个值传入指定函数，并返回该值。

var sayX = x => console.log('x is ' + x);
R.tap(sayX)(100) // 100

R.pipe(
  R.assoc('a', 2),
  R.tap(console.log),
  R.assoc('a', 3)
)({a: 1})
// {a: 3}

zipWith：将两个数组对应位置的值，一起作为参数传入某个函数。

var f = (x, y) => {
  // ...
};
R.zipWith(f, [1, 2, 3])(['a', 'b', 'c'])
// [f(1, 'a'), f(2, 'b'), f(3, 'c')]

apply：将数组转成参数序列，传入指定函数。

var nums = [1, 2, 3, -99, 42, 6, 7];
R.apply(Math.max)(nums) // 42

applySpec：返回一个模板函数，该函数会将参数传入模板内的函数执行，然后将执行结果填充到模板。

var getMetrics = R.applySpec({
  sum: R.add,
  nested: { mul: R.multiply }
});

getMetrics(2, 4) // { sum: 6, nested: { mul: 8 } }

ascend：返回一个升序排列的比较函数，主要用于排序。

var byAge = R.ascend(R.prop('age'));
var people = [
  // ...
];
var peopleByYoungestFirst = R.sort(byAge)(people);

descend：返回一个降序排列的比较函数，主要用于排序。

var byAge = R.descend(R.prop('age'));
var people = [
  // ...
];
var peopleByOldestFirst = R.sort(byAge)(people);

六、数组

6.1 数组的特征判断

contains：如果包含某个成员，返回true。

R.contains(3)([1, 2, 3]) // true
R.contains(4)([1, 2, 3]) // false
R.contains({ name: 'Fred' })([{ name: 'Fred' }]) // true
R.contains([42])([[42]]) // true

all：所有成员都满足指定函数时，返回true，否则返回false

var equals3 = R.equals(3);
R.all(equals3)([3, 3, 3, 3]) // true
R.all(equals3)([3, 3, 1, 3]) // false

any：只要有一个成员满足条件，就返回true。

var lessThan0 = R.flip(R.lt)(0);
var lessThan2 = R.flip(R.lt)(2);
R.any(lessThan0)([1, 2]) // false
R.any(lessThan2)([1, 2]) // true

none：没有成员满足条件时，返回true。

var isEven = n => n % 2 === 0;

R.none(isEven)([1, 3, 5, 7, 9, 11]) // true
R.none(isEven)([1, 3, 5, 7, 8, 11]) // false

6.2 数组的截取和添加

head：返回数组的第一个成员。

R.head(['fi', 'fo', 'fum']) // 'fi'
R.head([])  // undefined
R.head('abc') // 'a'
R.head('') // ''

last：返回数组的最后一个成员。

R.last(['fi', 'fo', 'fum']) // 'fum'
R.last([]) // undefined
R.last('abc') // 'c'
R.last('') // ''

tail：返回第一个成员以外的所有成员组成的新数组。

R.tail([1, 2, 3])  // [2, 3]
R.tail([1, 2])     // [2]
R.tail([1])        // []
R.tail([])         // []

R.tail('abc')  // 'bc'
R.tail('ab')   // 'b'
R.tail('a')    // ''
R.tail('')     // ''

init：返回最后一个成员以外的所有成员组成的新数组。

R.init([1, 2, 3])  // [1, 2]
R.init([1, 2])     // [1]
R.init([1])        // []
R.init([])         // []

R.init('abc')  // 'ab'
R.init('ab')   // 'a'
R.init('a')    // ''
R.init('')     // ''

nth：取出指定位置的成员。

var list = ['foo', 'bar', 'baz', 'quux'];
R.nth(1)(list) // 'bar'
R.nth(-1)(list) // 'quux'
R.nth(-99)(list) // undefined

R.nth(2)('abc') // 'c'
R.nth(3)('abc') // ''

take：取出前 n 个成员。

R.take(1)(['foo', 'bar', 'baz']) // ['foo']
R.take(2)(['foo', 'bar', 'baz']) // ['foo', 'bar']
R.take(3)(['foo', 'bar', 'baz']) // ['foo', 'bar', 'baz']
R.take(4)(['foo', 'bar', 'baz']) // ['foo', 'bar', 'baz']
R.take(3)('ramda')               // 'ram'

takeLast：取出后 n 个成员。

R.takeLast(1)(['foo', 'bar', 'baz']) // ['baz']
R.takeLast(2)(['foo', 'bar', 'baz']) // ['bar', 'baz']
R.takeLast(3)(['foo', 'bar', 'baz']) // ['foo', 'bar', 'baz']
R.takeLast(4)(['foo', 'bar', 'baz']) // ['foo', 'bar', 'baz']
R.takeLast(3)('ramda')               // 'mda'

slice：从起始位置（包括）开始，到结束位置（不包括）为止，从原数组截取出一个新数组。

R.slice(1, 3)(['a', 'b', 'c', 'd']) // ['b', 'c']
R.slice(1, Infinity)(['a', 'b', 'c', 'd']) // ['b', 'c', 'd']
R.slice(0, -1)(['a', 'b', 'c', 'd']) // ['a', 'b', 'c']
R.slice(-3, -1)(['a', 'b', 'c', 'd']) // ['b', 'c']
R.slice(0, 3)('ramda') // 'ram'

remove：移除开始位置后的n个成员。

R.remove(2, 3)([1,2,3,4,5,6,7,8]) // [1,2,6,7,8]

insert：在指定位置插入给定值。

R.insert(2, 'x')([1,2,3,4]) // [1,2,'x',3,4]

insertAll：在指定位置，插入另一个数组的所有成员。

R.insertAll(2，['x','y','z'])([1,2,3,4]) // [1,2,'x','y','z',3,4]

prepend：在数组头部插入一个成员

R.prepend('fee')(['fi', 'fo', 'fum'])
// ['fee', 'fi', 'fo', 'fum']

append：在数组尾部追加新的成员。

R.append('tests')(['write', 'more']) // ['write', 'more', 'tests']
R.append('tests')([]) // ['tests']
R.append(['tests'])(['write', 'more']) // ['write', 'more', ['tests']]

intersperse：在数组成员之间插入表示分隔的成员。

R.intersperse('n')(['ba', 'a', 'a'])
// ['ba', 'n', 'a', 'n', 'a']

join：将数组合并成一个字符串，并在成员之间插入分隔符。

R.join('|')([1, 2, 3]) // '1|2|3'

6.3 数组的过滤

filter：过滤出符合条件的成员。

var isEven = n => n % 2 === 0;
R.filter(isEven)([1, 2, 3, 4]) // [2, 4]

reject：过滤出所有不满足条件的成员。

var isOdd = (n) => n % 2 === 1;
R.reject(isOdd)([1, 2, 3, 4]) // [2, 4]

takeWhile：一旦满足条件，后面的成员都会被过滤。

var isNotFour = x => x !== 4;
R.takeWhile(isNotFour)([1, 2, 3, 4, 3, 2, 1]) // [1, 2, 3]

dropWhile：一旦不满足条件，取出剩余的所有成员。

var lteTwo = x => x <= 2;
R.dropWhile(lteTwo)([1, 2, 3, 4, 3, 2, 1])
// [3, 4, 3, 2, 1]

without：返回指定值以外的成员。

R.without([1, 2])([1, 2, 1, 3, 4])
// [3, 4]

6.4 单数组运算

countBy：对每个成员执行指定函数以后，返回一个对象，表示各种执行结果分别包含多少成员。

var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];
R.countBy(Math.floor)(numbers)  // {'1': 3, '2': 2, '3': 1}

var letters = ['a', 'b', 'A', 'a', 'B', 'c'];
R.countBy(R.toLower)(letters)  // {'a': 3, 'b': 2, 'c': 1}

splitAt：在给定位置，将原数组分成两个部分。

R.splitAt(1)([1, 2, 3]) // [[1], [2, 3]]
R.splitAt(5)('hello world') // ['hello', ' world']
R.splitAt(-1)('foobar') // ['fooba', 'r']

splitEvery：按照指定的个数，将原数组分成多个部分。

R.splitEvery(3)([1, 2, 3, 4, 5, 6, 7])
// [[1, 2, 3], [4, 5, 6], [7]]

R.splitEvery(3)('foobarbaz')
// ['foo', 'bar', 'baz']

splitWhen：以第一个满足指定函数的成员为界，将数组分成两个部分。

R.splitWhen(R.equals(2))([1, 2, 3, 1, 2, 3])
// [[1], [2, 3, 1, 2, 3]]

aperture：每个成员与其后给定数量的成员分成一组，这些组构成一个新的数组。

R.aperture(3)([1, 2, 3, 4, 5, 6, 7])
// [[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6], [5, 6, 7]]

partition：根据是否满足指定函数，将成员分区。

R.partition(R.contains('s'))(['sss', 'ttt', 'foo', 'bars'])
// => [ [ 'sss', 'bars' ],  [ 'ttt', 'foo' ] ]

indexOf：某个值在数组中第一次出现的位置。

R.indexOf(3)([1,2,3,4]) // 2
R.indexOf(10)([1,2,3,4]) // -1

lastIndexOf：某个值在数组中最后一次出现的位置。

R.lastIndexOf(3)([-1,3,3,0,1,2,3,4]) // 6
R.lastIndexOf(10)([1,2,3,4]) // -1

map：数组的每个成员依次执行某个函数。

var double = x => x * 2;
R.map(double)([1, 2, 3]) // [2, 4, 6]

mapIndexed：与map类似，区别是遍历函数可以额外获得两个参数：索引位置和原数组。

var mapIndexed = R.addIndex(R.map);
mapIndexed(
  (val, idx) => idx + '-' + val, ['f', 'o', 'o', 'b', 'a', 'r']
)
// ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']

forEach：数组的每个成员依次执行某个函数，总是返回原数组。

var printXPlusFive = x => console.log(x + 5);
R.forEach(printXPlusFive, [1, 2, 3]) // [1, 2, 3]
// logs 6
// logs 7
// logs 8

reduce：数组成员依次执行指定函数，每一次的运算结果都会进入一个累积变量。

var mySubtract = function (a, b) {
  return a - b;
};
R.reduce(mySubtract, 0)([1, 2, 3, 4]) // -10

reduceRight：与reduce类似，区别是数组成员从左到右执行。

R.reduceRight(R.subtract, 0)([1, 2, 3, 4]) // -2

reduceWhile：与reduce类似，区别是有一个判断函数，一旦数组成员不符合条件，就停止累积。

var isOdd = (acc, x) => x % 2 === 1;
var xs = [1, 3, 5, 60, 777, 800];
R.reduceWhile(isOdd, R.add, 0)(xs) // 9

var ys = [2, 4, 6];
R.reduceWhile(isOdd, R.add, 111)(ys) // 111

sort：按照给定函数，对数组进行排序。

var diff = function(a, b) { return a - b; };
R.sort(diff)([4,2,7,5])
// [2, 4, 5, 7]

sortWith：按照给定的一组函数，进行多重排序。

var alice = {
  name: 'alice',
  age: 40
};
var bob = {
  name: 'bob',
  age: 30
};
var clara = {
  name: 'clara',
  age: 40
};
var people = [clara, bob, alice];
var ageNameSort = R.sortWith([
  R.descend(R.prop('age')),
  R.ascend(R.prop('name'))
]);
ageNameSort(people); //=> [alice, clara, bob]

adjust：对指定位置的成员执行给定的函数。

R.adjust(R.add(10), 1)([1, 2, 3]) // [1, 12, 3]
R.adjust(R.add(10)，1)([1, 2, 3]) // [1, 12, 3]

ap：数组成员分别执行一组函数，将结果合成为一个新数组。

R.ap([R.multiply(2), R.add(3)])([1,2,3])
// [2, 4, 6, 4, 5, 6]

R.ap([R.concat('tasty '), R.toUpper])(['pizza', 'salad'])
// ["tasty pizza", "tasty salad", "PIZZA", "SALAD"]

flatten：将嵌套数组铺平。

R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]])
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

groupBy：将数组成员依次按照指定条件两两比较，并按照结果将所有成员放入子数组。

R.groupWith(R.equals)([0, 1, 1, 2, 3, 5, 8, 13, 21])
// [[0], [1, 1], [2], [3], [5], [8], [13], [21]]

R.groupWith((a, b) => a % 2 === b % 2)([0, 1, 1, 2, 3, 5, 8, 13, 21])
// [[0], [1, 1], [2], [3, 5], [8], [13, 21]]

R.groupWith(R.eqBy(isVowel), 'aestiou')
//=> ['ae', 'st', 'iou']

6.5 双数组运算

concat：将两个数组合并成一个数组。

R.concat('ABC')('DEF') // 'ABCDEF'
R.concat([4, 5, 6])([1, 2, 3]) // [4, 5, 6, 1, 2, 3]
R.concat([])([]) // []

zip：将两个数组指定位置的成员放在一起，生成一个新数组。

R.zip([1, 2, 3])(['a', 'b', 'c'])
// [[1, 'a'], [2, 'b'], [3, 'c']]

zipObj：将两个数组指定位置的成员分别作为键名和键值，生成一个新对象。

R.zipObj(['a', 'b', 'c'])([1, 2, 3])
// {a: 1, b: 2, c: 3}

xprod：将两个数组的成员两两混合，生成一个新数组。

R.xprod([1, 2])(['a', 'b'])
// [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]

intersection：返回两个数组相同的成员组成的新数组。

R.intersection([1,2,3,4], [7,6,5,4,3]) // [4, 3]

intersectionWith：返回经过某种运算，有相同结果的两个成员。

var buffaloSpringfield = [
  {id: 824, name: 'Richie Furay'},
  {id: 956, name: 'Dewey Martin'},
  {id: 313, name: 'Bruce Palmer'},
  {id: 456, name: 'Stephen Stills'},
  {id: 177, name: 'Neil Young'}
];
var csny = [
  {id: 204, name: 'David Crosby'},
  {id: 456, name: 'Stephen Stills'},
  {id: 539, name: 'Graham Nash'},
  {id: 177, name: 'Neil Young'}
];

R.intersectionWith(R.eqBy(R.prop('id'))，buffaloSpringfield)(csny)
// [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]

difference：返回第一个数组不包含在第二个数组里面的成员。

R.difference([1,2,3,4])([7,6,5,4,3]) // [1,2]
R.difference([7,6,5,4,3])([1,2,3,4]) // [7,6,5]
R.difference([{a: 1}, {b: 2}])([{a: 1}, {c: 3}]) // [{b: 2}]

differenceWith：返回执行指定函数后，第一个数组里面不符合条件的所有成员。

var cmp = (x, y) => x.a === y.a;
var l1 = [{a: 1}, {a: 2}, {a: 3}];
var l2 = [{a: 3}, {a: 4}];
R.differenceWith(cmp, l1)(l2) // [{a: 1}, {a: 2}]

symmetricDifference：返回两个数组的非共有成员所组成的一个新数组。

R.symmetricDifference([1,2,3,4])([7,6,5,4,3]) // [1,2,7,6,5]
R.symmetricDifference([7,6,5,4,3])([1,2,3,4]) // [7,6,5,1,2]

symmetricDifferenceWith：根据指定条件，返回两个数组所有运算结果不相等的成员所组成的新数组。

var eqA = R.eqBy(R.prop('a'));
var l1 = [{a: 1}, {a: 2}, {a: 3}, {a: 4}];
var l2 = [{a: 3}, {a: 4}, {a: 5}, {a: 6}];
R.symmetricDifferenceWith(eqA, l1, l2) // [{a: 1}, {a: 2}, {a: 5}, {a: 6}]

6.6 复合数组

find：返回符合指定条件的成员。

var xs = [{a: 1}, {a: 2}, {a: 3}];
R.find(R.propEq('a', 2))(xs) // {a: 2}
R.find(R.propEq('a', 4))(xs) // undefined

findIndex：返回符合指定条件的成员的位置。

var xs = [{a: 1}, {a: 2}, {a: 3}];
R.findIndex(R.propEq('a', 2))(xs) // 1
R.findIndex(R.propEq('a', 4))(xs) // -1

findLast：返回最后一个符合指定条件的成员。

var xs = [{a: 1, b: 0}, {a:1, b: 1}];
R.findLast(R.propEq('a', 1))(xs) // {a: 1, b: 1}
R.findLast(R.propEq('a', 4))(xs) // undefined

findLastIndex：返回最后一个符合指定条件的成员的位置。

var xs = [{a: 1, b: 0}, {a:1, b: 1}];
R.findLastIndex(R.propEq('a', 1))(xs) // 1
R.findLastIndex(R.propEq('a', 4))(xs) // -1

pluck：取出数组成员的某个属性，组成一个新数组。

R.pluck('a')([{a: 1}, {a: 2}]) // [1, 2]
R.pluck(0)([[1, 2], [3, 4]])   // [1, 3]

project：取出数组成员的多个属性，组成一个新数组。

var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};
var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};
var kids = [abby, fred];
R.project(['name', 'grade'])(kids)
// [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]

transpose：将每个成员相同位置的值，组成一个新数组。

R.transpose([[1, 'a'], [2, 'b'], [3, 'c']])
// [[1, 2, 3], ['a', 'b', 'c']]

R.transpose([[1, 2, 3], ['a', 'b', 'c']])
// [[1, 'a'], [2, 'b'], [3, 'c']]

R.transpose([[10, 11], [20], [], [30, 31, 32]])
// [[10, 20, 30], [11, 31], [32]]

mergeAll：将数组的成员合并成一个对象。

R.mergeAll([{foo:1},{bar:2},{baz:3}])
// {foo:1,bar:2,baz:3}

R.mergeAll([{foo:1},{foo:2},{bar:2}])
// {foo:2, bar:2}

fromPairs：将嵌套数组转为一个对象。

R.fromPairs([['a', 1], ['b', 2], ['c', 3]])
// {a: 1, b: 2, c: 3}

groupBy：将数组成员按照指定条件分组。

var byGrade = R.groupBy(function(student) {
  var score = student.score;
  return score < 65 ? 'F' :
         score < 70 ? 'D' :
         score < 80 ? 'C' :
         score < 90 ? 'B' : 'A';
});
var students = [{name: 'Abby', score: 84},
                {name: 'Eddy', score: 58},
                // ...
                {name: 'Jack', score: 69}];
byGrade(students);
// {
//   'A': [{name: 'Dianne', score: 99}],
//   'B': [{name: 'Abby', score: 84}]
//   // ...,
//   'F': [{name: 'Eddy', score: 58}]
// }

sortBy：根据成员的某个属性排序。

var sortByFirstItem = R.sortBy(R.prop(0));
sortByFirstItem([[-1, 1], [-2, 2], [-3, 3]])
// [[-3, 3], [-2, 2], [-1, 1]]

var sortByNameCaseInsensitive = R.sortBy(
  R.compose(R.toLower, R.prop('name'))
);
var alice = {name: 'ALICE', age: 101};
var bob = {name: 'Bob', age: -10};
var clara = {name: 'clara', age: 314.159};
var people = [clara, bob, alice];
sortByNameCaseInsensitive(people)
// [alice, bob, clara]

七、对象

7.1 对象的特征判断

has: 返回一个布尔值，表示对象自身是否具有该属性。

var hasName = R.has('name')
hasName({name: 'alice'})   //=> true
hasName({name: 'bob'})     //=> true
hasName({})                //=> false

var point = {x: 0, y: 0};
var pointHas = R.has(R.__, point);
pointHas('x')  // true
pointHas('y')  // true
pointHas('z')  // false

hasIn：返回一个布尔值，表示对象自身或原型链上是否具有某个属性。

function Rectangle(width, height) {
  this.width = width;
  this.height = height;
}
Rectangle.prototype.area = function() {
  return this.width * this.height;
};

var square = new Rectangle(2, 2);
R.hasIn('width')(square)  // true
R.hasIn('area')(square)  // true

propEq：如果属性等于给定值，返回true。

var abby = {name: 'Abby', age: 7, hair: 'blond'};
var fred = {name: 'Fred', age: 12, hair: 'brown'};
var rusty = {name: 'Rusty', age: 10, hair: 'brown'};
var alois = {name: 'Alois', age: 15, disposition: 'surly'};
var kids = [abby, fred, rusty, alois];
var hasBrownHair = R.propEq('hair', 'brown');
R.filter(hasBrownHair)(kids) // [fred, rusty]

whereEq：如果属性等于给定值，返回true。

var pred = R.whereEq({a: 1, b: 2});

pred({a: 1})              // false
pred({a: 1, b: 2})        // true
pred({a: 1, b: 2, c: 3})  // true
pred({a: 1, b: 1})        // false

where：如果各个属性都符合指定条件，返回true。

var pred = R.where({
  a: R.equals('foo'),
  b: R.complement(R.equals('bar')),
  x: R.gt(__, 10),
  y: R.lt(__, 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

7.2 对象的过滤

omit：过滤指定属性。

R.omit(['a', 'd'])({a: 1, b: 2, c: 3, d: 4})
// {b: 2, c: 3}

filter：返回所有满足条件的属性

var isEven = n => n % 2 === 0;
R.filter(isEven)({a: 1, b: 2, c: 3, d: 4}) // {b: 2, d: 4}

reject：返回所有不满足条件的属性

var isOdd = (n) => n % 2 === 1;
R.reject(isOdd)({a: 1, b: 2, c: 3, d: 4})
// {b: 2, d: 4}

7.3 对象的截取

dissoc：过滤指定属性。

R.dissoc('b')({a: 1, b: 2, c: 3})
// {a: 1, c: 3}

assoc：添加或改写某个属性。

R.assoc('c', 3)({a: 1, b: 2})
// {a: 1, b: 2, c: 3}

partition：根据属性值是否满足给定条件，将属性分区。

R.partition(R.contains('s'))({ a: 'sss', b: 'ttt', foo: 'bars' })
// [ { a: 'sss', foo: 'bars' }, { b: 'ttt' }  ]

pick：返回指定属性组成的新对象

R.pick(['a', 'd'])({a: 1, b: 2, c: 3, d: 4})
// {a: 1, d: 4}

R.pick(['a', 'e', 'f'])({a: 1, b: 2, c: 3, d: 4})
// {a: 1}

pickAll：与pick类似，但会包括不存在的属性。

R.pickAll(['a', 'd'])({a: 1, b: 2, c: 3, d: 4})
// {a: 1, d: 4}

R.pickAll(['a', 'e', 'f'])({a: 1, b: 2, c: 3, d: 4})
// {a: 1, e: undefined, f: undefined}

pickBy：返回符合条件的属性

var isUpperCase = (val, key) => key.toUpperCase() === key;
R.pickBy(isUpperCase)({a: 1, b: 2, A: 3, B: 4})
// {A: 3, B: 4}

keys：返回对象自身属性的属性名组成的新数组。

R.keys({a: 1, b: 2, c: 3}) // ['a', 'b', 'c']

keysIn：返回对象自身的和继承的属性的属性名组成的新数组。

var F = function() { this.x = 'X'; };
F.prototype.y = 'Y';
var f = new F();
R.keysIn(f) // ['x', 'y']

values：返回对象自身的属性的属性值组成的数组。

R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]

valuesIn：返回对象自身的和继承的属性的属性值组成的数组。

var F = function() { this.x = 'X'; };
F.prototype.y = 'Y';
var f = new F();
R.valuesIn(f) // ['X', 'Y']

invertObj：将属性值和属性名互换。如果多个属性的属性值相同，只返回最后一个属性。

var raceResultsByFirstName = {
  first: 'alice',
  second: 'jake',
  third: 'alice',
};
R.invertObj(raceResultsByFirstName)
// {"alice": "third", "jake": "second"}

invert：将属性值和属性名互换，每个属性值对应一个数组。

var raceResultsByFirstName = {
  first: 'alice',
  second: 'jake',
  third: 'alice',
};
R.invert(raceResultsByFirstName)
// { 'alice': ['first', 'third'], 'jake':['second'] }

7.4 对象的运算

prop：返回对象的指定属性

R.prop('x')({x: 100})
// 100

R.prop('x')({})
// undefined

map：对象的所有属性依次执行某个函数。

var double = x => x * 2;
R.map(double)({x: 1, y: 2, z: 3})
// {x: 2, y: 4, z: 6}

mapObjIndexed：与map类似，但是会额外传入属性名和整个对象。

var values = { x: 1, y: 2, z: 3 };
var prependKeyAndDouble = (num, key, obj) => key + (num * 2);

R.mapObjIndexed(prependKeyAndDouble)(values)
// { x: 'x2', y: 'y4', z: 'z6' }

forEachObjIndexed：每个属性依次执行给定函数，给定函数的参数分别是属性值和属性名，返回原对象。

var printKeyConcatValue = (value, key) => console.log(key + ':' + value);
R.forEachObjIndexed(printKeyConcatValue)({x: 1, y: 2}) // {x: 1, y: 2}
// logs x:1
// logs y:2

merge：合并两个对象，如果有同名属性，后面的值会覆盖掉前面的值。

R.merge({ 'name': 'fred', 'age': 10 })({ 'age': 40 })
// { 'name': 'fred', 'age': 40 }

var resetToDefault = R.merge(R.__, {x: 0});
resetToDefault({x: 5, y: 2}) // {x: 0, y: 2}

mergeWith：合并两个对象，如果有同名属性，会使用指定的函数处理。

R.mergeWith(
  R.concat,
  { a: true, values: [10, 20] },
  { b: true, values: [15, 35] }
);
// { a: true, b: true, values: [10, 20, 15, 35] }

eqProps：比较两个对象的指定属性是否相等。

var o1 = { a: 1, b: 2, c: 3, d: 4 };
var o2 = { a: 10, b: 20, c: 3, d: 40 };
R.eqProps('a', o1)(o2) // false
R.eqProps('c', o1)(o2) // true

R.evolve：对象的属性分别经过一组函数的处理，返回一个新对象。

var tomato  = {
  firstName: '  Tomato ',
  data: {elapsed: 100, remaining: 1400},
  id: 123
};
var transformations = {
  firstName: R.trim,
  lastName: R.trim, // 不会被调用
  data: {elapsed: R.add(1), remaining: R.add(-1)}
};
R.evolve(transformations)(tomato)
// {
//   firstName: 'Tomato',
//   data: {elapsed: 101, remaining: 1399},
//   id: 123
// }

7.5 复合对象

path：取出数组中指定路径的值。

R.path(['a', 'b'], {a: {b: 2}}) // 2
R.path(['a', 'b'], {c: {b: 2}}) // undefined

pathEq：返回指定路径的值符合条件的成员

var user1 = { address: { zipCode: 90210 } };
var user2 = { address: { zipCode: 55555 } };
var user3 = { name: 'Bob' };
var users = [ user1, user2, user3 ];
var isFamous = R.pathEq(['address', 'zipCode'], 90210);
R.filter(isFamous)(users) // [ user1 ]

assocPath：添加或改写指定路径的属性的值。

R.assocPath(['a', 'b', 'c'], 42)({a: {b: {c: 0}}})
// {a: {b: {c: 42}}}

R.assocPath(['a', 'b', 'c'], 42)({a: 5})
// {a: {b: {c: 42}}}

近期开课

Cisco Certified Network Associate 训练营

2025/10/11 06:13 (Sydney)

Python零基础入门

2025/02/12 03:14 (Sydney)

Web全栈班24期 NodeJS方向

2024/12/08 11:30 (Sydney)

We Accept

Top Categories

Web全栈班 DevOps项目班数据工程全栈班数据分析项目班编程入门班 Business Analyst实习算法集训营

求职就业

BA和产品经理实习数据科学实习数据分析实习 Marketing实习简历修改面试指导导师指导VIP

地址

Level 10b, 144 Edward Street, Brisbane CBD(Headquarter)

Level 2, 171 La Trobe St, Melbourne VIC 3000

四川省成都市武侯区桂溪街道天府大道中段500号D5东方希望天祥广场B座45A13号

Business Hub, 155 Waymouth St, Adelaide SA 5000

联系方式

hello@jiangren.com.au 0421-672-555

Disclaimer

JR Academy acknowledges Traditional Owners of Country throughout Australia and recognises the continuing connection to lands, waters and communities. We pay our respect to Aboriginal and Torres Strait Islander cultures; and to Elders past and present. Aboriginal and Torres Strait Islander peoples should be aware that this website may contain images or names of people who have since passed away.

ABN 26621887572