Question

我这里有一个愚蠢的人，我在如何更轻松地解决这个问题上完全空白。

因此，我有一个property对象。那有它自己的一些道具。现在，取决于这些道具的状态，该属性处于其生命周期的某个步骤。目前，结果可以从第1步转到第3步，但还会有更多结果。

找到当前步骤是否比这样做更简单：

const computeStep = (property) => {
  const { has_binding_offer, has_non_binding_offer } = property;
  let step;
  if (has_non_binding_offer.state === false
      && has_binding_offer.state === false) {
    step = 1;
  }
  if (has_non_binding_offer.state === true
      && has_binding_offer.state === false) {
    step = 2;
  }
  if (has_non_binding_offer.state === true
      && has_binding_offer.state === true) {
    step = 3;
  }

  return step;
};

谢谢

Answer 1

您可以使用商品信息对步骤进行编码，然后使用简单的过滤器找到相应的步骤：

const steps = [
  { step: 1,
    non_binding: false,
    binding: false 
  },
  { step: 2,
    non_binding: true, 
    binding: false,
  },
  { step: 3,
    non_binding: true,
    binding: true
  }
];

const computeStep  = ({ has_binding_offer, has_non_binding_offer }) => {
  const [step] = steps.filter(s => s.non_binding === has_non_binding_offer 
                                   && s.binding === has_binding_offer)
                      .map(s => s.step);

  return step;
}

侧面问题：对于两个值，应该有4个唯一状态，但是我看到您并没有代表has_binding_offer === true和has_non_binding_offer === false的情况。这仅仅是领域的事情吗？

Answer 2

因为错误的值等于0，而真正的值等于1，因此可以使用：

step = has_non_binding_offer.state + has_binding_offer.state +1

但是，如果您依赖于特定的属性，则该方法会失效。

我希望使用@Hunter McMillen代码。

Answer 3

您可以用其他方式拆分决策-首先确定has_non_binding_offer.state，然后确定has_binding_offer.state。

我使用三元方程来减少if语句的内容。

const computeStep = (property) => {
  const { has_binding_offer, has_non_binding_offer } = property;
  let step;

  has_non_binding_offer.state
      ? (step = has_binding_offer.state ? 3 : 2)
      : (step = has_binding_offer.state ? null : 1);
  return step;
};

Answer 4

可以使用布尔算法将布尔列表表示为整数。

例如const logs = [ "2018-08-31T12:52:44.357174404+00:00", "2018-08-31T12:52:44.357133365+00:00", "2018-08-31T12:52:44.357185085+00:00", "2018-08-31T12:52:44.357192810+00:00", "2018-08-31T12:52:40.197139820+00:00", "2018-08-31T12:52:40.197829400+00:00" ]; const seconds = logs.map(l => l.slice(0, 19)); const histogram = seconds.reduce((hist, val) => { hist[val] = (hist[val] || 0) + 1; return hist; }, {}); console.log(histogram); 101 [true, false, true] => binary 4 * 1 + 2 * 0 + 1 * 1 == 5`。

使用JavaScript的另一种简单方法是：

==

（我最初写过const reducer = (acc, value) => (acc << 1) | value; const toBits = arr => arr.reduce(reducer);，但是JS隐式地进行了此转换）

示例：(acc << 1) | (value ? 1 : 0)的值为[true, true, false].reduce((acc, val) => (acc << 1) | val)。

因此您可以这样做：

这会为每个可能的输入返回一个不同的整数，并且适用于最多32个布尔值的数组。

还请注意：您已经在代码中进行对象分解，但是我已经将其移至函数参数中，以保存一行代码和否则未使用的变量const computeStep = ({ has_binding_offer, has_non_binding_offer }) => [has_binding_offer, has_non_binding_offer] .map( v => v.state ) .reduce( (acc, value) => (acc << 1) | value );。

要使其返回所需的准确结果，您可能需要使用以下一项进行调整：

调整输入数组的顺序，以便布尔值在必要的位置职位
使用整数作为映射的键：property
使用整数作为return stepMap[bits]语句的输入：switch

Answer 5

您可以使用数据结构将组合映射到值：

var offerMap = {
    false: { false: 1 },
    true: { false: 2, true: 3 }
};
step = offerMap[has_non_binding_offer.state][has_binding_offer.state];

Answer 6

（未经测试的）做同一件事吗？

const comp = (p) => p.has_non_binding_offer.state ? p.has_binding_offer.state ? 3 : 2 : 1

某些人反对嵌套条件（三元）运算符。但是我认为它们是最清晰的解决方案。

如果您愿意，也可以像这样格式化它：

const computeStep = (property) => property.has_non_binding_offer.state 
  ? property.has_binding_offer.state 
    ? 3 
    : 2 
  : 1

价值计算更简单

6 个答案: