List
R.filter
R.find
R.findIndex
R.uniq
R.map
Function
R.curry
R.compose
Object
R.clone
R.prop
R.propEq
R.filter过滤
给定一个过滤条件(谓词)，对可过滤对象如数组，进行过滤，返回过滤后相同类型的数据。
过滤条件是一个函数返回一个bool值，过滤时，可过滤对象会去一个一个去匹配，返回bool值为真的组成一个新的数据集合。
var isEven = n => n % 2 === 0;//定义过滤函数
var res = R.filter(isEven,[1,2,3,4]);
console.log(res);//[ 2, 4 ]
var res = R.filter(isEven,{
a:1,
b:2,
c:3,
d:4
});
console.log(res);//{ b: 2, d: 4 }
R.find 查找返回元素
给定一个查找条件(过滤条件)，返回第一个查到的元素，找不到返回undefined
var xs = [{a:1},{a:2,b:5},{a:3}];
var res = R.find(R.propEq('a',2))(xs);
console.log(res);//{ a: 2, b: 5 }
var res = R.find(R.propEq('a',4))(xs);
console.log(res);//undefined
R.findIndex 查找返回索引
R.find是返回第一个查找到的元素，这个是返回那个元素的索引，找不到返回-1
var res = R.findIndex(R.propEq('a',2))(xs);
console.log(res);//1
var res = R.findIndex(R.propEq('a',4))(xs);
console.log(res);//-1
R.uniq 唯一不重复
返回一个新的数组，这个数组是对原数组中唯一值的一个拷贝，也就是说除去了重复值。
console.log(R.uniq([1,1,2,1])
,R.uniq([1,'1'])
,R.uniq([[42],[42]]));//[ 1, 2 ] [ 1, '1' ] [ [ 42 ] ]
R.map 映射
映射，Ramda为数组和对象都实现了map方法，此方法接受一个函数和一个函子，将函数应用到每个函子的值，并返回一个相同形状的函子。(作用于数组或对象中的每一个值，返回函数处理过的数组或对象，这是一个新的数组或对象)
var double = x => x * 2;
var list1 = [1,2,3];
var list2 = R.map(double)(list1);
console.log(list1 === list2,list2);//false [ 2, 4, 6 ] 即便乘以1 也是false，这符合curry化函数很纯的特点
console.log(R.map(double)({a:1,b:2,c:3}));//{ a: 2, b: 4, c: 6 }
R.curry
接收一个函数，返回一个和原函数等价的curry化后的函数，这个curry化后的函数具备了两个不同寻常的能力。
1.函数的参数不必一次性提供所有参数，它可以一次提供一个或多个，假如函数f有三个参数，g是fcurry后的函数 g=R.curry(f),那么下面的4中写法都是等价的。
g(1)(2)(3)
g(1)(2, 3)
g(1, 2)(3)
g(1, 2, 3)
2.你可以使用特殊的占位符值R.__,这个占位符也许可以称之为留白，这允许部分参数进行合适的组合而不管他们的位置，如果g和上面的一样，那么下面是等价的。
g(1, 2, 3)
g(R.__, 2, 3)(1)
g(R.__, R.__, 3)(1)(2)
g(R.__, R.__, 3)(1, 2)
g(R.__, 2)(1)(3)
g(R.__, 2)(1, 3)
g(R.__, 2)(_, 3)(1)
意思就是，R.__作为一个占位符一样的存在，后续传递的参数会依次填充占位符。
关于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);
console.log(g(4));//10
curry化的函数，在没返回结果之前，每一步都返回的是一个函数，参数不用依次给完，每次想给几个给几个。就是这么灵活和任性。
R.compose 构造从右到左执行的函数
构造一个从右向左执行的函数，最右边的那个函数可以有任意参数，其余的函数必须是一元的。注意 compose的结果不会自动curried。
var classyGreeting = (firstName, lastName) => "The name's " + lastName + ", " + firstName + " " + lastName
//构造的这个函数先执行右边的函数，再执行左边的函数 最右边返回的结果会作为参数传递给左边的函数
var yellGreeting = R.compose(R.toUpper, classyGreeting);
// var res = yellGreeting('James')('Bond');//error 不自动curry
var res = yellGreeting('James','Bond')
console.log(res);//THE NAME'S BOND, JAMES BOND
// curry化一下
console.log(R.curry(yellGreeting)('James')('Bond'));//THE NAME'S BOND, JAMES BOND
var res = R.compose(Math.abs,R.add(1),R.multiply(2))(-4);// 2*-4=-8 +1 = -7 绝对值为7
console.log(res);
注意上面 -4之前返回的是一个从右向左执行的构造函数，(-4)是传入参数-4开始执行。注意不要把括号圈错位置了。
R.clone 拷贝
这是一个深拷贝，创建可能包含（嵌套）数组和对象，数字，字符串，布尔值和日期的值的深层副本。函数是通过引用分配的，而不是复制的。
var objects = [{}, {}, {}];
var objectsClone = R.clone(objects);
objects === objectsClone; //=> false
objects[0] === objectsClone[0]; //=> false
R.prop 属性
返回对象关联的属性，不存在返回undefined
console.log(R.prop('x', {x: 100,y:200}));//100
console.log(R.prop('z', {x: 100,y:200}));//undefined
R.propEq 属性等于
如果指定的对象属性在R.equals条件下等于给定值，则返回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');
var res = R.filter(hasBrownHair)(kids);
console.log(res);//[ { name: 'Fred', age: 12, hair: 'brown' },
{ name: 'Rusty', age: 10, hair: 'brown' } ]
propEq就是属性等于的意思，给定以个属性和一个值，如果匹配返回真，否则返回假，和filter搭配使用很好用。
网友评论