Question

我有这段代码：

int someValue = 100;
if (x == 5)
{
    if (someCondition)
    {
        return someValue;
    }
    return someValue / 12;
}

if (x == 6)
{
     if (someCondition)
     {
         return someValue * 12;
     }
    return someValue;
}

如您所见， someCondition 始终相同，只是返回的值不同。有没有办法简化这个？

Answer 1

让我们看看，你怎么看待这个？

int someValue = 100;

if (x == 5)
 return someCondition ? someValue : (someValue / 12);
else if (x == 6)
 return someCondition ? (someValue * 12) : someValue;

Answer 2

这取决于你的意思，简化......

以下代码行数较少，并且在可读性（IMO）方面没有牺牲任何内容：

var someValue = 100;
switch (x)
{
  case 5:
    return someCondition ? someValue : someValue / 12;
  case 6:
    return someCondition ? someValue * 12 : someValue;
  default:
    return someValue;
}

Answer 3

这没有“嵌套”语句，所以看起来更干净：

int someValue = 100;

if ((x == 5 && someCondition) || (x == 6 && !someCondition))
    return someValue;

if (x == 5)
    return someValue / 12;

if (x == 6)
    return someValue * 12;

Answer 4

您有不同的方法来处理相同条件语句的结果。因此，保持它的方式可能更有效（并且更容易在眼睛上）。

如果每个条件语句的return表达式相同，那么我会修改代码，但每个代码块都有不同的return值，因此这使得它是唯一的。

所以不，真的没有办法简化你所做的事情。

Answer 5

你有两个变量（x和someCondition），还有3个不同的结果;所以，是的，你可以比两对两个嵌套测试做得更好。你能做的最好的是：

if (((x == 5) && someCondition)) ||
    ((x == 6) && !someCondition)))
{
  return someValue;
}
else if (x == 5)
{
  return someValue / 12;
}
else if (x == 6)
{
  return someValue * 12;
}

Answer 6

您可以切换if语句，这样您只需重复一次条件。您可以使用switch来检查x值：

int someValue = 100;
if (someCondition) {
  switch (x) {
    case 5: return someValue;
    case 6: return someValue * 12;
  }
} else {
  switch (x) {
    case 5: return someValue / 12;
    case 6: return someValue;
  }
}

Answer 7

非常多，

Double scalar = 12;
switch(x)
{
  case 5 : 
    scalar = 1f/12;
    break;
  case 6 : 
    break;
  default : 
    return 100;
}
if (someCondition)     
{         
  return someValue;     
}     
return someValue * scalar;

Answer 8

一行代码：

condition ? someValue * ((x == 6) ? 12 : 1) : someValue / ((x == 5) ? 12 : 1);

这很简单吗？我是这么认为的 这是否易于理解？在某种程度上 这样好吗？我不会这么说。（+生成的IL略有不同）

Answer 9

switch(x) {
    case 5: return someCondition ? someValue : someValue / 12;
    case 6: return someCondition ? someValue * 12 : someValue;
}

Answer 10

我个人会使用switch语句而不是两个if语句。或者您可以创建一个传递x * 12或x / 12 ...

的函数

Answer 11

使用对象而不是开关，添加了“采用”测试。

const state = {
  5: {
    true: (someValue) => someValue,
    false: (someValue) => someValue / 12
  },
  6: {
    true: (someValue) => someValue * 12,
    false: (someValue) => someValue
  }
}

const test_values = [0, -1 , 1, 12, -12, 1.2, -1.2]

test_values.map(value => Object.keys(state).map(x => Object.keys(state[x]).map(condition => {
  console.log(`value = ${value}, x = ${x}, result = ${state[x][condition](value)}`)
})))

如果条件简化？

11 个答案: