ramda 函数 relation type

查看所有的函数类型

const list = [...document.querySelectorAll(".label.label-category.pull-right")]
R.uniq(R.map(i => i.innerText, list))

type

const R = require("ramda")

// is
// 检测一个对象（val）是否是给定构造函数的实例。该函数会依次检测其原型链，如果存在的话。
R.is(Object, {}); //=> true
R.is(Number, 1); //=> true
R.is(Object, 1); //=> false
R.is(String, "s"); //=> true
R.is(String, new String("")); //=> true
R.is(Object, new String("")); //=> true
R.is(Object, "s"); //=> false
R.is(Number, {}); //=> false

// isNil
// 检测输入值是否为 null 或 undefined 。
console.log(
  R.isNil(null), //=> true
  R.isNil(undefined), //=> true
  R.isNil(0), //=> false
  R.isNil([]), //=> false
  R.isNil(false), //=> false
)

// propIs
// 判断指定对象的属性是否为给定的数据类型，是则返回 true ；否则返回 false 。
R.propIs(Number, "x", {x: 1, y: 2});  //=> true
R.propIs(Number, "x", {x: "foo"});    //=> false
R.propIs(Number, "x", {});            //=> false

// type
// 用一个单词来描述输入值的（原生）类型，返回诸如 "Object"、"Number"、"Array"、"Null" 之类的结果。
// 不区分用户自定义的类型，统一返回 "Object"。
R.type({}); //=> "Object"
R.type(1); //=> "Number"
R.type(false); //=> "Boolean"
R.type("s"); //=> "String"
R.type(null); //=> "Null"
R.type([]); //=> "Array"
R.type(/[A-z]/); //=> "RegExp"
R.type(() => {}); //=> "Function"
R.type(undefined); //=> "Undefined"

Relation

const R = require("ramda")

// clamp
// 将数字限制在指定的范围内。
// clamp 也可用于其他有序类型，如字符串和日期。
R.clamp(1, 10, -5) // => 1
R.clamp(1, 10, 15) // => 10
R.clamp(1, 10, 4)  // => 4

// countBy
// 根据给定函数提供的统计规则对列表中的元素进行分类计数。返回一个对象，
// 其键值对为：fn 根据列表元素生成键，列表中通过 fn 映射为对应键的元素的个数作为值。
// 注意，由于 JavaScript 对象的实现方式，所有键都被强制转换为字符串。
// 若在列表位置中给出 transfomer，则用作 transducer 。
const numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];
R.countBy(Math.floor)(numbers);    //=> {"1": 3, "2": 2, "3": 1}

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

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


// 求第一个列表中未包含在第二个列表中的所有元素的集合（集合中没有重复元素）。
// 两列表中的元素通过 predicate 判断相应元素是否同时 “包含在” 两列表中。
const cmp = (x, y) => x.a === y.a;
const l1 = [{a: 1}, {a: 2}, {a: 3}];
const l2 = [{a: 3}, {a: 4}];
R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]

// eqBy
// 接受一个函数和两个值，通过传入函数对两个值进行相等性判断。如果两个值的计算结果相等，则返回 true ；否则返回 false 。
R.eqBy(Math.abs, 5, -5); //=> true


// equals
// 如果传入的参数相等，返回 true；否则返回 false。可以处理几乎所有 JavaScript 支持的数据结构。
// 若两个参数自身存在 equals 方法，则对称地调用自身的 equals 方法。
R.equals(1, 1); //=> true
R.equals(1, "1"); //=> false
R.equals([1, 2, 3], [1, 2, 3]); //=> true
const a = {};
a.v = a;
const b = {};
b.v = b;
R.equals(a, b); //=> true

// gt
// 如果首个参数大于第二个参数，返回 true；否则返回 false。
R.gt(2, 1); //=> true
R.gt(2, 2); //=> false
R.gt(2, 3); //=> false
R.gt("a", "z"); //=> false
R.gt("z", "a"); //=> true


// gte
// 如果首个参数大于或等于第二个参数，返回 true；否则返回 false。
R.gte(2, 1); //=> true
R.gte(2, 2); //=> true
R.gte(2, 3); //=> false
R.gte("a", "z"); //=> false
R.gte("z", "a"); //=> true

// identical
// 如果两个参数是完全相同，则返回 true，否则返回 false。如果它们引用相同的内存，
// 也认为是完全相同的。NaN 和 NaN 是完全相同的；0 和 -0 不是完全相同的。
const o = {};
R.identical(o, o); //=> true
R.identical(1, 1); //=> true
R.identical(1, "1"); //=> false
R.identical([], []); //=> false
R.identical(0, -0); //=> false
R.identical(NaN, NaN); //=> true
console.log((0) === (-0))  // true


// innerJoin 类似数据库查询
// 接受一个 predicate pred 、列表 xs 和 ys ，返回列表 xs"。依次取出 xs 中的元素，
// 若通过 pred 判断等于 ys 中的一个或多个元素，则放入 xs" 。
// pred 必须为二元函数，两个参数分别来自于对应两个列表中的元素。
// xs、ys 和 xs" 被当作集合处理，所以从语义上讲，元素的顺序并不重要，
// 但由于 xs" 是列表（列表中元素有排列顺序），所以本实现保证 xs" 中元素的顺序与 xs 中的一致。
// 重复的元素也不会被移除，因此，若 xs 中含重复元素，xs" 中也会包含元素。
R.innerJoin(
  (record, id) => record.id === id,
  [{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"}],
  [177, 456, 999]
);
//=> [{id: 456, name: "Stephen Stills"}, {id: 177, name: "Neil Young"}]

// intersection
// 取出两个 list 中相同的元素组成的 set （集合：没有重复元素）。
R.intersection([1, 2, 3, 4], [7, 6, 5, 4, 3]); //=> [4, 3]

// lt
// 如果首个参数小于第二个参数，返回 true；否则返回 false。
R.lt(2, 1); //=> false
R.lt(2, 2); //=> false
R.lt(2, 3); //=> true
R.lt("a", "z"); //=> true
R.lt("z", "a"); //=> false


// lte
// 如果首个参数小于或等于第二个参数，返回 true；否则返回 false。
R.lte(2, 1); //=> false
R.lte(2, 2); //=> true
R.lte(2, 3); //=> true
R.lte("a", "z"); //=> true
R.lte("z", "a"); //=> false


// max
// 返回两个参数中的较大值。
R.max(789, 123); //=> 789
R.max("a", "b"); //=> "b"

// maxBy
// 接收一个函数和两个值，返回使给定函数执行结果较大的值。
//  square :: Number -> Number
const square = n => n * n;
R.maxBy(square, -3, 2); //=> -3
R.reduce(R.maxBy(square), 0, [3, -5, 4, 1, -2]); //=> -5
R.reduce(R.maxBy(square), 0, []); //=> 0


// min
// 返回两个参数中的较小值。
R.min(789, 123); //=> 123
R.min("a", "b"); //=> "a"

// minBy
// 接收一个函数和两个值，返回使给定函数执行结果较小的值。
//  square :: Number -> Number
R.minBy(square, -3, 2); //=> 2
R.reduce(R.minBy(square), Infinity, [3, -5, 4, 1, -2]); //=> 1
R.reduce(R.minBy(square), Infinity, []); //=> Infinity

// pathEq
// 判断对象的嵌套路径上是否为给定的值，通过 R.equals 函数进行相等性判断。常用于列表过滤。
const user1 = {address: {zipCode: 90210}};
const user2 = {address: {zipCode: 55555}};
const user3 = {name: "Bob"};
const users = [user1, user2, user3];
const isFamous = R.pathEq(["address", "zipCode"], 90210);
R.filter(isFamous, users); //=> [ user1 ]
console.log(
  R.pathEq(["a", "b"], {}, {}) // 不存在的值为false
)

// propEq
// 如果指定对象属性与给定的值相等，则返回 true ；否则返回 false 。通过 R.equals 函数进行相等性判断。可以使用 R.whereEq 进行多个属性的相等性判断。
const abby = {name: "Abby", age: 7, hair: "blond"};
const fred = {name: "Fred", age: 12, hair: "brown"};
const rusty = {name: "Rusty", age: 10, hair: "brown"};
const alois = {name: "Alois", age: 15, disposition: "surly"};
const kids = [abby, fred, rusty, alois];
const hasBrownHair = R.propEq("hair", "brown");
R.filter(hasBrownHair, kids); //=> [fred, rusty]

// sortBy
// 根据给定的函数对列表进行排序。
const sortByFirstItem = R.sortBy(R.prop(0));
const pairs = [[-1, 1], [-2, 2], [-3, 3]];
sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]

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

// sortWith
// 依据比较函数列表对输入列表进行排序。
const alice = {
  name: "alice",
  age: 40
};
const bob = {
  name: "bob",
  age: 30
};
const clara = {
  name: "clara",
  age: 40
};
const people = [clara, bob, alice];
const ageNameSort = R.sortWith([
  R.descend(R.prop("age")),
  R.ascend(R.prop("name"))
]);
ageNameSort(people); //=> [alice, clara, bob]

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


// 求对称差集。所有不属于两列表交集元素的集合。交集的元素由条件函数的返回值决定。
const eqA = R.eqBy(R.prop("a"));
const l1 = [{a: 1}, {a: 2}, {a: 3}, {a: 4}];
const l2 = [{a: 3}, {a: 4}, {a: 5}, {a: 6}];
R.symmetricDifferenceWith(eqA, l1, l2); //=> [{a: 1}, {a: 2}, {a: 5}, {a: 6}]


// union
// 集合并运算，合并两个列表为新列表（新列表中无重复元素）。
R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]

// unionWith
// 集合并运算，合并两个列表为新列表（新列表中无重复元素）。由 predicate 的返回值决定两元素是否重复。
const l1 = [{a: 1}, {a: 2}];
const l2 = [{a: 1}, {a: 4}];
R.unionWith(R.eqBy(R.prop("a")), l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]