kk常用ramda函数总结

持续更新。。。

参考了ramda官网和阮一峰老师的Ramda 函数库参考教程。

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

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 = R.gt(R.__, 10)
var lt20 = R.lt(R.__, 20)
var f = R.both(gt10, lt20);
f(15); //=> true
f(30); //=> false

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

var isQueen = R.propEq('rank', 'Q');
var isSpade = R.propEq('suit', '♠︎');
var isQueenOfSpades = R.allPass([isQueen, isSpade]);

isQueenOfSpades({rank: 'Q', suit: '♣︎'}); //=> false
isQueenOfSpades({rank: 'Q', suit: '♠︎'}); //=> true

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

R.test(/^x/, 'xyz'); //=> true
R.test(/^y/, 'xyz'); //=> false

数组

contains：如果包含某个成员，返回true(类似于es6中的Array.includes)。

all：所有成员都满足指定函数时，返回true，否则返回false（类似于es5的Array.every）。

any：只要有一个成员满足条件，返回true（类似于es5中的some）。

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

head：返回数组或者字符串的第一个成员，空数组会返回undefined。

R.head(['fi', 'fo', 'fum']); //=> 'fi'
R.head([]); //=> undefined

R.head('abc'); //=> 'a'
R.head(''); //=> ''

last

filter：过滤出符合条件的成员(类似于es5的Array.filter)。

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

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

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]

groupBy：Splits a list into sub-lists stored in an object, based on the result of calling a String-returning function on each element, and grouping the results according to values returned.

把一个数组按照函数返回的结果分成多个数组存在一个对象中，该函数返回值为字符串。

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}]
// }

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}

findIndex：返回符合指定条件的成员的位置(类似es6中的Array.findIndex)。

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}

对象

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

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

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

omit：过滤指定属性。

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