让属性被另一个属性指向的最干净的 fp 方法是什么

Question

给定一个可能为 null 且可能具有以下属性的对象：

{
  templateId: "template1",
  templates: {
    template1: "hello"
  }
}

您将如何以故障安全的方式获取模板？（templateId 可能未定义，或者它引用的模板可能未定义）

我使用 ramda 并试图调整我的原始代码版本以使用类似 Maybe adt 的东西来避免显式 null/undefined 检查。

我想不出一个优雅干净的解决方案。

原始 ramda 版本：

const getTemplate = obj => {
  const templateId = obj && prop("templateId", obj);
  const template = templateId != null && path(["template", templateId], obj);
  return template;
}

这确实有效，但我想避免空值检查，因为我的代码还有很多事情要做，如果能变得更干净就更好了

编辑我从几个答案中得到最好的办法是首先确保干净的数据。但这并不总是可能的。我也想出了这个，我很喜欢。

const Empty=Symbol("Empty"); 
const p = R.propOr(Empty);
const getTemplate = R.converge(p,[p("templateId"), p("templates")]);

想要获得有关它的清晰度和可读性的反馈（以及是否存在会破坏它的边缘情况）

Answer 1

试试这个，

const input = {
  templateId: "template1",
  templates: {
    template1: "hello"
  }
};

const getTemplate = (obj) => {
    const template = obj.templates[obj.templateId] || "any default value / simply remove this or part";
    //use below one if you think templates might be undefined too,
    //const template = obj.templates && obj.templates[obj.templateId] || "default value"
    return template;
}
console.log(getTemplate(input));

您可以使用 && 和 || 的组合使表达式短路。

此外，如果键存储在变量中，则对对象使用 []（而不是 .）来获取值。

完成检查

const getTemplate = (obj) => {
    const template = obj && obj.templateId && obj.templates && obj.templates[obj.templateId] || "default value"
    return template;
}

Answer 2

您可以使用 R.pathOr。只要路径的任何部分不可用，就会返回默认值。例如：

const EmptyTemplate = Symbol();

const getTemplateOrDefault = obj => R.pathOr(
  EmptyTemplate,
  [ "templates", obj.templateId ],
  obj
);

可以在 this snippet 中找到一组测试。该示例表明 pathOr 可以很好地处理所有 (?) "wrong" 个案例：

const tests = [
  { templateId: "a",  templates: { "a": 1 } }, // 1
  {                   templates: { "a": 1 } }, // "empty"
  { templateId: "b",  templates: { "a": 1 } }, // "empty"
  { templateId: null, templates: { "a": 1 } }, // "empty"
  { templateId: "a",  templates: {        } }, // "empty"
  { templateId: "a"                         }  // "empty"
];

编辑： 要支持 null 或 undefined 输入，您可以使用快速 defaultTo:

const templateGetter = compose(
  obj => pathOr("empty", [ "templates", obj.templateId ], obj),
  defaultTo({})
);

Answer 3

这是一个普通的 ADT 方法 Javascript:

// type constructor

const Type = name => {
  const Type = tag => Dcons => {
    const t = new Tcons();
    t[`run${name}`] = Dcons;
    t.tag = tag;
    return t;
  };

  const Tcons = Function(`return function ${name}() {}`) ();
  return Type;  
};

const Maybe = Type("Maybe");

// data constructor

const Just = x =>
  Maybe("Just") (cases => cases.Just(x));

const Nothing =
  Maybe("Nothing") (cases => cases.Nothing);

// typeclass functions

Maybe.fromNullable = x =>
  x === null
    ? Nothing
    : Just(x);

Maybe.map = f => tx =>
  tx.runMaybe({Just: x => Just(f(x)), Nothing});

Maybe.chain = ft => tx =>
  tx.runMaybe({Just: x => ft(x), Nothing});

Maybe.compk = ft => gt => x => 
  gt(x).runMaybe({Just: y => ft(y), Nothing});

// property access

const prop =
  k => o => o[k];

const propSafe = k => o =>
  k in o
    ? Just(o[k])
    : Nothing;

// auxiliary function

const id = x => x;

// test data

// case 1

const o = {
  templateId: "template1",
  templates: {
    template1: "hello"
  }
};

// case 2

const p = {
  templateId: null
};

// case 3

const q = {};

// case 4

const r = null; // ignored

// define the action (a function with a side effect)

const getTemplate = o => {
  const tx = Maybe.compk(Maybe.fromNullable)
    (propSafe("templateId"))
      (o);

  return Maybe.map(x => prop(x) (o.templates)) (tx);
};

/* run the effect,
   that is what it means to compose functions that may not produce a value */


console.log("case 1:",
  getTemplate(o).runMaybe({Just: id, Nothing: "N/A"})
);

console.log("case 2:",
  getTemplate(p).runMaybe({Just: id, Nothing: "N/A"})
);

console.log("case 3:",
  getTemplate(q).runMaybe({Just: id, Nothing: "N/A"})
);

如您所见，我使用函数对 ADT 进行编码，因为 Javascript 在语言级别不支持它们。这种编码称为Church/Scott编码。 Scott 编码在设计上是不可变的，一旦您熟悉它，它的处理就是小菜一碟。

Just 值和 Nothing 都是 Maybe 类型，并且包括一个 tag 属性，您可以在其中进行模式匹配。

[编辑]

由于 Scott（不是刚才的编码人员）和 OP 要求更详细的回复，我扩展了我的代码。我仍然忽略对象本身是 null 的情况。您必须在前面的步骤中处理此问题。

您可能认为这是过度设计的 - 可以肯定的是这个人为的例子。但是当复杂性增加时，这些函数式风格可以减轻痛苦。另请注意，我们可以用这种方法处理各种效果，而不仅仅是 null 检查。

例如，我目前正在构建一个 FRP 解决方案，它基本上基于相同的构建块。这种模式的重复是功能范式的特征之一，我不想再没有它了。

Answer 4

正如其他人告诉您的那样，丑陋的数据阻碍了美丽的代码。清理您的空值或将它们表示为选项类型。

也就是说，ES6 确实允许您通过一些繁重的解构分配来处理这个问题

const EmptyTemplate =
  Symbol ()

const getTemplate = ({ templateId, templates: { [templateId]: x = EmptyTemplate } }) =>
  x
  
console.log
  ( getTemplate ({ templateId: "a", templates: { a: "hello" }}) // "hello"
  , getTemplate ({ templateId: "b", templates: { a: "hello" }}) // EmptyTemplate
  , getTemplate ({                  templates: { a: "hello" }}) // EmptyTemplate
  )

你可以继续让getTemplate更具防御性。例如，下面我们接受用一个空对象调用我们的函数，甚至根本没有输入

const EmptyTemplate =
  Symbol ()

const getTemplate =
  ( { templateId
    , templates: { [templateId]: x = EmptyTemplate } = {}
    }
  = {}
  ) =>
    x
 
console.log
  ( getTemplate ({ templateId: "a", templates: { a: "hello" }}) // "hello"
  , getTemplate ({ templateId: "b", templates: { a: "hello" }}) // EmptyTemplate
  , getTemplate ({                  templates: { a: "hello" }}) // EmptyTemplate
  , getTemplate ({})                                            // EmptyTemplate
  , getTemplate ()                                              // EmptyTemplate
  )

以上，我们开始有点痛。这个信号很重要，不要忽视，因为它警告我们做错了什么。如果您必须支持那么多空检查，则表明您需要在程序的其他区域收紧代码。 copy/paste 逐字逐句地回答其中任何一个问题并错过每个人试图教给你的教训是不明智的。

让属性被另一个属性指向的最干净的 fp 方法是什么

What's the cleanest fp way to get a property pointed by another property

javascript

functional-programming

ramda.js

sanctuary

让 属性 被另一个 属性 指向的最干净的 fp 方法是什么

What's the cleanest fp way to get a property pointed by another property

javascript

functional-programming

ramda.js

sanctuary

让属性被另一个属性指向的最干净的 fp 方法是什么