当前位置：自学咖网 > 技术教程 > 编程最新 > ramda 函数 Object
wenwen 编程最新

ramda 函数 Object

ramda 函数 Object

函数式的语义性相当精准, 就一个merge都有好几种

对于属性区分也很明确, 是对象本身的还是原型链上的都有不同的函数名表达出这种不一致

由此带来的当然也是记忆力的挑战, 这么单纯的过一遍感觉记不住啊

 

const R = require("ramda")

// assoc
// 浅复制对象，然后设置或覆盖对象的指定属性。
// 注意，该函数也会将 prototype 属性复制到新的对象中。所有 non-primitive 属性都通过引用复制。

R.assoc("c", 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}

// assocPath
// 浅复制对象，设置或覆盖即将创建的给定路径所需的节点，并将特定值放在该路径的末端。
// 注意，这也会将 prototype 属性复制到新对象上。所有 non-primitive 属性都通过引用复制。
R.assocPath(["a", "b", "c"], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}

// Any missing or non-object keys in path will be overridden
R.assocPath(["a", "b", "c"], 42, {a: 5}); //=> {a: {b: {c: 42}}}

// clone
// 深复制。其值可能（嵌套）包含 Array、Object、Number、String、Boolean、Date 类型的数据。Function 通过引用复制。
// 若自身存在 clone 方法，则调用自身的 clone 方法。
const objects = [{}, {}, {}];
const objectsClone = R.clone(objects);
objects === objectsClone; //=> false
objects[0] === objectsClone[0]; //=> false

// dissoc
// 删除对象中指定 prop 属性。
let obj1 = {a: 1, b: 2, c: 3, deep: {}}
let obj2 = R.dissoc("b", obj1);
// 注意, 其中对象中的值是浅复制
// { a: 1, b: 2, c: 3, deep: {} } { a: 1, c: 3, deep: {} } false true
console.log(obj1, obj2, obj1 === obj2, obj1.deep === obj2.deep)

// eqProps
// 判断两个对象指定的属性值是否相等。通过 R.equals 函数进行相等性判断。可用作柯里化的 predicate 。
const o1 = {a: 1, b: 2, c: 3, d: 4};
const o2 = {a: 10, b: 20, c: 3, d: 40};
R.eqProps("a", o1, o2); //=> false
R.eqProps("c", o1, o2); //=> true

// evolve
// 递归地对 object 的属性进行变换，变换方式由 transformation 函数定义。所有非原始类型属性都通过引用来复制。
// 如果某个 transformation 函数对应的键在被变换的 object 中不存在，那么该方法将不会执行。
const tomato = {firstName: "  Tomato ", data: {elapsed: 100, remaining: 1400}, id: 123};
const transformations = {
  firstName: R.trim,
  lastName: R.trim, // Will not get invoked.
  data: {elapsed: R.add(1), remaining: R.add(-1)}
};
R.evolve(transformations, tomato); //=> {firstName: "Tomato", data: {elapsed: 101, remaining: 1399}, id:123}


// 遍历 object，对 object 中的每对 key 和 value 执行方法 fn。
// fn 接收三个参数: (value, key, obj).
const printKeyConcatValue = (value, key) => console.log(key + ":" + value);
R.forEachObjIndexed(printKeyConcatValue, {x: 1, y: 2, z: {m: 0}});
// x:1
// y:2
// z:[object Object]

// has
// 如果对象自身含有指定的属性，则返回 true；否则返回 false。
const hasName = R.has("name");
hasName({name: "alice"});   //=> true
hasName({name: "bob"});     //=> true
hasName({});                //=> false

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

// hasIn
// 如果对象自身或其原型链上含有指定的属性，则返回 true；否则返回 false。
function Rectangle(width, height) {
  this.width = width;
  this.height = height;
}

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

const square = new Rectangle(2, 2);
R.hasIn("width", square);  //=> true
R.hasIn("area", square);  //=> true

// hasPath
// 检查对象中是否存在指定的路径。只检查对象自身的属性。
R.hasPath(["a", "b"], {a: {b: 2}});         // => true
R.hasPath(["a", "b"], {a: {b: undefined}}); // => true
R.hasPath(["a", "b"], {a: {c: 2}});         // => false
R.hasPath(["a", "b"], {});                  // => false

// invert
// 与 R.invertObj 类似，但会将值放入数组中，来处理一个键对应多个值的情况。
const raceResultsByFirstName = {
  first: "alice",
  second: "jake",
  third: "alice",
};
R.invert(raceResultsByFirstName);
//=> { "alice": ["first", "third"], "jake":["second"] }

// invertObj
// 将对象的键、值交换位置：值作为键，对应的键作为值。交换后的键会被强制转换为字符串。注意，如果原对象同一值对应多个键，采用最后遍历到的键。
const raceResults2 = {
  first: "alice",
  second: "jake"
};
R.invertObj(raceResults2);
//=> { "alice": "first", "jake":"second" }

// Alternatively:
const raceResults3 = ["alice", "jake"];
R.invertObj(raceResults3);
//=> { "alice": "0", "jake":"1" }

// keys
// 返回给定对象所有可枚举的、自身属性的属性名组成的列表。注意，不同 JS 运行环境输出数组的顺序可能不一致。
R.keys({a: 1, b: 2, c: 3}); //=> ["a", "b", "c"]

// keysIn
// 返回给定对象所有属性（包括 prototype 属性）的属性名组成的列表。注意，不同 JS 运行环境输出数组的顺序可能不一致。
const F = function () {
  this.x = "X";
};
F.prototype.y = "Y";
const f = new F();
R.keysIn(f); //=> ["x", "y"]

// lens
// 返回封装了给定 getter 和 setter 方法的 lens 。 getter 和 setter 分别用于 “获取” 和 “设置” 焦点（lens 聚焦的值）。setter 不会改变原数据。
const xLens = R.lens(R.prop("x"), R.assoc("x"));
R.view(xLens, {x: 1, y: 2});            //=> 1
R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}
R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}

// lensIndex
// 返回聚焦到指定索引的 lens。
const headLens = R.lensIndex(0);
R.view(headLens, ["a", "b", "c"]);            //=> "a"
R.set(headLens, "x", ["a", "b", "c"]);        //=> ["x", "b", "c"]
R.over(headLens, R.toUpper, ["a", "b", "c"]); //=> ["A", "b", "c"]

// lensPath
// 返回聚焦到指定路径的 lens。
const xHeadYLens = R.lensPath(["x", 0, "y"]);

R.view(xHeadYLens, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});
//=> 2
R.set(xHeadYLens, 1, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});
//=> {x: [{y: 1, z: 3}, {y: 4, z: 5}]}
R.over(xHeadYLens, R.negate, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});
//=> {x: [{y: -2, z: 3}, {y: 4, z: 5}]}

// lensProp
// 返回聚焦到指定属性的 lens。
const xLens2 = R.lensProp("x");
R.view(xLens2, {x: 1, y: 2});            //=> 1
R.set(xLens2, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}
R.over(xLens2, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}

// mapObjIndexed
// Object 版本的 map。mapping function 接受三个参数： (value, key, obj) 。如果仅用到参数 value，则用 map 即可。
const xyz = {x: 1, y: 2, z: 3};
const prependKeyAndDouble = (num, key, obj) => key + (num * 2);

R.mapObjIndexed(prependKeyAndDouble, xyz); //=> { x: "x2", y: "y4", z: "z6" }

// merge 已经被废弃
// 合并两个对象的自身属性（不包括 prototype 属性）。如果某个 key 在两个对象中都存在，使用后一个对象对应的属性值。
R.merge({"name": "fred", "age": 10}, {"age": 40});
//=> { "name": "fred", "age": 40 }
const withDefaults = R.merge({x: 0, y: 0});
withDefaults({y: 2}); //=> {x: 0, y: 2}

// mergeDeepLeft
// 合并两个对象的自身属性（不包括 prototype 属性）。如果某个 key 在两个对象中都存在：
// 并且两个值都是对象，则继续递归合并这两个值。
// 否则，采用第一个对象的值。
R.mergeDeepLeft({name: "fred", age: 10, contact: {email: "moo@example.com"}},
  {age: 40, contact: {email: "baa@example.com"}});
//=> { name: "fred", age: 10, contact: { email: "moo@example.com" }}


// mergeDeepRight
// 合并两个对象的自身属性（不包括 prototype 属性）。如果某个 key 在两个对象中都存在：
// 并且两个值都是对象，则继续递归合并这两个值。
// 否则，采用第二个对象的值。
R.mergeDeepRight({name: "fred", age: 10, contact: {email: "moo@example.com"}},
  {age: 40, contact: {email: "baa@example.com"}});
//=> { name: "fred", age: 40, contact: { email: "baa@example.com" }}


// mergeDeepWith
// 合并两个对象的自身属性（不包括 prototype 属性）。如果某个 key 在两个对象中都存在：
// 并且两个关联的值都是对象，则继续递归合并这两个值。
// 否则，使用给定函数对两个值进行处理，并将返回值作为该 key 的新值。
// 如果某 key 只存在于一个对象中，该键值对将作为结果对象的键值对。
R.mergeDeepWith(R.concat,
  {a: true, c: {values: [10, 20]}},
  {b: true, c: {values: [15, 35]}});
//=> { a: true, b: true, c: { values: [10, 20, 15, 35] }}

// mergeDeepWithKey
// 合并两个对象的自身属性（不包括 prototype 属性）。如果某个 key 在两个对象中都存在：
// 并且两个关联的值都是对象，则继续递归合并这两个值。
// 否则，使用给定函数对该 key 和对应的两个值进行处理，并将返回值作为该 key 的新值。
// 如果某 key 只存在于一个对象中，该键值对将作为结果对象的键值对。
let concatValues = (k, l, r) => k === "values" ? R.concat(l, r) : r
R.mergeDeepWithKey(concatValues,
  {a: true, c: {thing: "foo", values: [10, 20]}},
  {b: true, c: {thing: "bar", values: [15, 35]}});
//=> { a: true, b: true, c: { thing: "bar", values: [10, 20, 15, 35] }}

// mergeLeft
// 合并两个对象的自身属性（不包括 prototype 属性）。如果某个 key 在两个对象中都存在，使用前一个对象对应的属性值。
R.mergeLeft({"age": 40}, {"name": "fred", "age": 10});
//=> { "name": "fred", "age": 40 }
const resetToDefault = R.mergeLeft({x: 0});
resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}


// 合并两个对象的自身属性（不包括 prototype 属性）。如果某个 key 在两个对象中都存在，使用后一个对象对应的属性值。
R.mergeRight({"name": "fred", "age": 10}, {"age": 40});
//=> { "name": "fred", "age": 40 }
const withDefaults3 = R.mergeRight({x: 0, y: 0});
withDefaults3({y: 2}); //=> {x: 0, y: 2}


// mergeWith
// 使用给定的两个对象自身属性（不包括 prototype 属性）来创建一个新对象。
// 如果某个 key 在两个对象中都存在，则使用给定的函数对每个对象该 key 对应的 value 进行处理，处理结果作为新对象该 key 对应的值。
R.mergeWith(R.concat,
  {a: true, values: [10, 20]},
  {b: true, values: [15, 35]});
//=> { a: true, b: true, values: [10, 20, 15, 35] }

// mergeWithKey
// 使用给定的两个对象自身属性（不包括 prototype 属性）来创建一个新对象。
// 如果某个 key 在两个对象中都存在，则使用给定的函数对该 key 和每个对象该 key 对应的 value 进行处理，处理结果作为新对象该 key 对应的值。
let concatValues4 = (k, l, r) => k == "values" ? R.concat(l, r) : r
R.mergeWithKey(concatValues4,
  {a: true, thing: "foo", values: [10, 20]},
  {b: true, thing: "bar", values: [15, 35]});
//=> { a: true, b: true, thing: "bar", values: [10, 20, 15, 35] }

// objOf
// 创建一个包含单个键值对的对象。
const matchPhrases = R.compose(
  R.objOf("must"),
  R.map(R.objOf("match_phrase"))
);
//=> {must: [{match_phrase: "foo"}, {match_phrase: "bar"}, {match_phrase: "baz"}]}
matchPhrases(["foo", "bar", "baz"]);

// omit
// 删除对象中给定的 keys 对应的属性。
R.omit(["a", "d"], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}

// over
// 对数据结构中被 lens 聚焦的部分进行函数变换。
const headLens2 = R.lensIndex(0);
R.over(headLens2, R.toUpper, ["foo", "bar", "baz"]); //=> ["FOO", "bar", "baz"]

// path
// 取出给定路径上的值。
R.path(["a", "b"], {a: {b: 2}}); //=> 2
R.path(["a", "b"], {c: {b: 2}}); //=> undefined
R.path(["a", "b", 0], {a: {b: [1, 2, 3]}}); //=> 1
R.path(["a", "b", -2], {a: {b: [1, 2, 3]}}); //=> 2

// pathOr
// 如果非空对象在给定路径上存在值，则将该值返回；否则返回给定的默认值。
R.pathOr("N/A", ["a", "b"], {a: {b: 2}}); //=> 2
R.pathOr("N/A", ["a", "b"], {c: {b: 2}}); //=> "N/A"


// paths
// 提取对象中指定路径数组（paths）上的对应的值（values）
R.paths([["a", "b"], ["p", 0, "q"]], {a: {b: 2}, p: [{q: 3}]}); //=> [2, 3]
R.paths([["a", "b"], ["p", "r"]], {a: {b: 2}, p: [{q: 3}]}); //=> [2, undefined]

// 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 类似，但 pickAll 会将不存在的属性以 key: undefined 键值对的形式返回。
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
// 返回对象的部分拷贝，其中仅包含 key 满足 predicate 的属性。
const isUpperCase = (val, key) => key.toUpperCase() === key;
R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}

// project
// 模拟 SQL 中的 select 语句。
const abby = {name: "Abby", age: 7, hair: "blond", grade: 2};
const fred = {name: "Fred", age: 12, hair: "brown", grade: 7};
const kids = [abby, fred];
R.project(["name", "grade"], kids); //=> [{name: "Abby", grade: 2}, {name: "Fred", grade: 7}]

// prop
//  取出对象中指定属性的值。如果不存在，则返回 undefined。
R.prop("x", {x: 100}); //=> 100
R.prop("x", {}); //=> undefined
R.prop(0, [100]); //=> 100
R.compose(R.inc, R.prop("x"))({x: 3}) //=> 4
// 不能使用路径写法
console.log(R.prop("x.y", {x: {y: 1}})); // undefined

// prop
// 对于给定的非空对象，如果指定属性存在，则返回该属性值；否则返回给定的默认值。
const alice = {
  name: "ALICE",
  age: 101
};
const favorite = R.prop("favoriteLibrary");
const favoriteWithDefault = R.propOr("Ramda", "favoriteLibrary");
favorite(alice);  //=> undefined
favoriteWithDefault(alice);  //=> "Ramda"


// props
// 返回 prop 的数组：输入为 keys 数组，输出为对应的 values 数组。values 数组的顺序与 keys 的相同。
R.props(["x", "y"], {x: 1, y: 2}); //=> [1, 2]
R.props(["c", "a", "b"], {b: 2, a: 1}); //=> [undefined, 1, 2]

const fullName = R.compose(R.join(" "), R.props(["first", "last"]));
fullName({last: "Bullet-Tooth", age: 33, first: "Tony"}); //=> "Tony Bullet-Tooth"

// set
// 通过 lens 对数据结构聚焦的部分进行设置。
const xLens3 = R.lensProp("x");

R.set(xLens3, 4, {x: 1, y: 2});  //=> {x: 4, y: 2}
R.set(xLens3, 8, {x: 1, y: 2});  //=> {x: 8, y: 2}

// toPairs
// 将一个对象的属性转换成键、值二元组类型的数组，只处理对象自身的属性。注意：不同 JS 运行环境输出数组的顺序可能不一致。
R.toPairs({a: 1, b: 2, c: 3}); //=> [["a", 1], ["b", 2], ["c", 3]]

// toPairsIn
// 将一个对象的属性转换成键、值二元组类型的数组，包括原型链上的属性。注意，不同 JS 运行环境输出数组的顺序可能不一致。
const F2 = function() { this.x = "X"; };
F2.prototype.y = "Y";
const f2 = new F2();
R.toPairsIn(f2); //=> [["x","X"], ["y","Y"]]

// values
// 返回对象所有自身可枚举的属性的值。注意：不同 JS 运行环境输出数组的顺序可能不一致。
R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]

// valuesIn
// 返回对象所有属性的值，包括原型链上的属性。注意：不同 JS 运行环境输出数组的顺序可能不一致。
const F3 = function() { this.x = "X"; };
F3.prototype.y = "Y";
const f3 = new F3();
R.valuesIn(f3); //=> ["X", "Y"]

// view
// 返回数据结构中，lens 聚焦的部分。lens 的焦点决定了数据结构中的哪部分是可见的。
const xLensX = R.lensProp("x");
R.view(xLensX, {x: 1, y: 2});  //=> 1
R.view(xLensX, {x: 4, y: 2});  //=> 4

// where
// 接受一个测试规范对象和一个待检测对象，如果测试满足规范，则返回 true，
// 否则返回 false。测试规范对象的每个属性值都必须是 predicate 。
// 每个 predicate 作用于待检测对象对应的属性值，
// 如果所有 predicate 都返回 true，则 where 返回 true，否则返回 false 。
// where 非常适合于需要声明式表示约束的函数，比如 filter 和 find 。
// pred :: Object -> Boolean
const pred = R.where({
  a: R.equals("foo"),
  b: R.complement(R.equals("bar")),
  x: R.gt(R.__, 10),
  y: R.lt(R.__, 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

// whereEq
// 接受一个测试规范对象和一个待检测对象，如果测试满足规范，则返回 true，否则返回 false。如果对于每一个测试规范对象的属性值，待检测对象中都有一个对应的相同属性值，则 where 返回 true，否则返回 false 。
// whereEq 是 where 的一种特殊形式。
// pred :: Object -> Boolean
const predEq = R.whereEq({a: 1, b: 2});

predEq({a: 1});              //=> false
predEq({a: 1, b: 2});        //=> true
predEq({a: 1, b: 2, c: 3});  //=> true
predEq({a: 1, b: 1});        //=> false

 

hmoban主题是根据ripro二开的主题，极致后台体验，无插件，集成会员系统
自学咖网 » ramda 函数 Object

wen 普通

分享到：

相关推荐

BeetlSQL 3 功能预览2

定义一个注解@Jackson能把属性对象转化成json存入到数据库 定义@LoadOne, 当数据加载完毕后，可以加载更多数据 定义@Matcher注解，影响Mapper的执行 多租户问题，通过定义@Tenant解决 B...

Python 的二元算术运算详解

相关学习推荐：python教程 大家对我解读属性访问的博客文章反应热烈，这启发了我再写一篇关于 Python 有多少语法实际上只是语法糖的文章。在本文中，我想谈谈二元算术运算。 具体来说，我想解读减法的工作原理：a - ...

Python函数与lambda 表达式（匿名函数）

Python函数 一、函数的作用 函数是组织好的，可重复使用的，用来实现单一或相关联功能的代码段 函数能提高应用的模块性和代码的重复利用率 python 内置函数：https://docs.python.org/zh-c...

如何利用python函数求导数

利用python函数求导数的方法：首先python运行环境，导入微分的模块包；然后定义符号变量和函数；接着求导【diff = diff(f,x)】；最后输入diff就显示其变量值了。 本教程操作环境：windows7系统...