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

Question

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

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

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

我使用 ramda 并试图调整我的原始代码版本以使用可能的广告来避免显式的空/未定义检查。

我没有想出一个优雅而干净的解决方案。

朴素的 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

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

也就是说，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
  )

上面，我们开始感到有点痛苦。这个信号很重要，不要忽视，因为它警告我们做错了什么。如果您必须支持这么多空检查，则表明您需要收紧程序其他区域的代码。逐字复制/粘贴其中任何一个答案并错过每个人都试图教给您的课程是不明智的。

Answer 2

这里是 vanilla Javascript 中的 ADT 方法：

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

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

const EmptyTemplate = Symbol();

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

可以在this snippet 中找到一系列测试。该示例显示pathOr 可以很好地处理所有（？）“错误”情况：

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 4

试试这个，

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;
}