0

我有一个这样设置的 if 语句

if (A && B) {
   // do something 1
} else {
   if (B) {
      // set some boolean to false
   } 
   // do something 2
}

我想知道我是否可以降低认知复杂性？现在这个分数是4分。

4

5 回答 5

0

那么你可能只有一个这样的深度：

function originalImplementation(A, B) {
  if (A && B) {
    console.log("do something 1");
  } else {
    if (B) {
      console.log("set some boolean to false");
    }
    console.log("do something 2");
  }
}

function newImplementation(A, B) {
  if (A && B) {
    console.log("do something 1");
  }
  else if (B) {
    console.log("set some boolean to false");
  }
  if (!A || !B) {
    console.log("do something 2");
  }
}

console.log("originalImplementation");

originalImplementation(0, 0);
originalImplementation(0, 1);
originalImplementation(1, 0);
originalImplementation(1, 1);

console.log("newImplementation");

newImplementation(0, 0);
newImplementation(0, 1);
newImplementation(1, 0);
newImplementation(1, 1);

于 2021-07-27T21:33:36.253 回答
0

首先设置布尔值可以设置更清晰的 if/else

if(!A && B) {
  // set some boolean to false
}

if (A && B) {
  // do something 1
} else {
  // do something 2
}

另一种策略是尽快退出功能

例如

if(X) {
  // do stuff

  return;
} 

if(Z)
{
  // do different stuff
  return; 
}

// do default stuff
return;

这允许读者忽略超出他们感兴趣的条件的逻辑

最后，您还可以创建具有有意义名称而不是注释的函数

if(X) {
  return doSomething2();
}
于 2021-07-27T21:48:44.287 回答
0

我想说降低认知复杂性的最好方法是使用函数。这类似于@GuerricP 原始答案，但处理多种情况do somthing 2

例如。

function doSomething2() {}

if (A && B) {
  // do something 1
} else if (B) {  
  // set some boolean to false
  doSomething2();
} else {
  doSomething2();
}

这降低了复杂性，因为在您的原始版本中，doSomething2 有 2 条路径并不明显。

于 2021-07-27T21:53:06.663 回答
0

我认为这是正确的方法，也是最干净的。

const DoSomething = function(){}

if (A && B) {
} 
else if (B) {  
DoSomething();
} 
else {
 DoSomething();
}
于 2021-07-27T22:25:22.320 回答
0

假设您对每种情况只做一件事，您可以尝试整理语法：

  1. 单行if语句不需要花括号
  2. 您可以通过提前返回来避免if,else if等
const run = (a, b) => {
  if (a && b) return fun1();
  if (a) return fun2();
  if (b) return fun3();
  return fun4();
}

在这种情况下，我更喜欢使用嵌套三元组。通常被行业中的工具制造商和意见领袖认为是“不好的做法”，但我认为通过正确的缩进，它们提供了更多的整理机会：

const run = (a, b) =>
  ( a && b ? fun1()
  : a      ? fun2()
  : b      ? fun3()
           : fun4());

当然是 YMMV ;)

于 2021-07-27T22:31:37.897 回答