4

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

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

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

我使用 ramda 并试图调整我的原始代码版本以使用可能的 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")]);

希望获得有关它的干净程度和可读性的反馈（以及是否存在会破坏它的边缘情况）

4

4 回答 4

4

这是 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 解决方案，它基本上基于相同的构建块。这种模式的重复是我不想再没有的功能范式的特征之一。

于 2018-04-23T13:13:57.560 回答
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
  )

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

于 2018-04-23T13:48:18.750 回答
3

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

const EmptyTemplate = Symbol();

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

可以在此代码段中找到一组测试。该示例显示可以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({})
);
于 2018-04-23T12:00:01.643 回答
0

试试这个，

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

于 2018-04-23T11:55:19.087 回答