如何简化嵌套的 if 语句树答案

【问题标题】：How to simplify a nested if statement tree如何简化嵌套的 if 语句树
【发布时间】：2019-04-04 00:12:20
【问题描述】：

我有一个嵌套的 if 语句树，它运行一个函数 16 次（我知道），每次都向函数发送一组不同的元素。

函数只返回真或假。

if(!checkSpecial(1,1,1,1)) {
    if(!checkSpecial(1,1,1,0)) {
        if(!checkSpecial(1,1,0,1)) {
            if(!checkSpecial(1,0,1,1)) {
                if(!checkSpecial(0,1,1,1)) {                                
                    if(!checkSpecial(1,1,0,0)) {                            
                        if(!checkSpecial(1,0,0,1)) {                            
                            if(!checkSpecial(0,0,1,1)) {                            
                                if(!checkSpecial(1,0,1,0)) {                            
                                    if(!checkSpecial(0,1,0,1)) {                            
                                        if(!checkSpecial(0,1,1,0)) {                    
                                            if(!checkSpecial(1,0,0,0)) {                    
                                                if(!checkSpecial(0,1,0,0)) {                    
                                                    if(!checkSpecial(0,0,1,0)) {                    
                                                        if(!checkSpecial(0,0,0,1)) {                    
                                                            if(!checkSpecial(0,0,0,0)) {
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }   
} else {
    // do other stuff
}

如你所见，如果函数在每一个实例中都返回 false，我想做其他事情。

如果函数返回 true，我不想做任何事情。

我的问题是，我知道必须有更好的方法来做到这一点，我假设通过某种循环，但我不知道这种类型的循环会被称为什么或它是如何工作的.

到目前为止我的修复：

for (var i = 0; i < 16; i++) { 
   // HELP!
}

任何指针将不胜感激。谢谢。

【问题讨论】：

1.将i 转换为4 位，以1 和0 的形式存储在数组中。 2. 使用Function.prototype.apply
如果不了解函数的作用，很难提供建议。
我不明白知道函数的作用有多重要。它请求 1 或 0 的 4 个输入，然后给出真或假答案。不管怎样，这个函数除了总是返回 false 之外什么都做不了……关键是如何简化 if 语句。
正如@Pointy 所说，在不知道函数实现了什么的情况下，很难提供任何可靠的东西。我能提供的唯一建议是将每个排列存储在一个数组中并对其进行迭代，而不是编写每个 if 语句。
一个调用返回真后你能中止吗？

标签： javascript loops if-statement

【解决方案1】：

您可以创建一个数字 0-15 的二进制表示的数组，然后检查 every 其中一个在以数组项作为参数调用函数时是否返回 false：

const combinations = Array.from(
  { length: 16 },
  (_, i) => (i >>> 0).toString(2).padStart(4, '0').split('').map(Number)
);

console.log(combinations)
/*
if (combinations.every(combination => checkSpecial(...combination) === false)) {
  // every result was false
} else {
  // at least one result wasn't false
}
*/

【讨论】：

这会重复一些值（例如，[1,0,0,0]）

【解决方案2】：

我唯一的建议如下：

用每个排列初始化一个数组

var permutations = [
	[0, 1, 1, 0],
  [1, 1, 1, 0]
];

遍历这些排列并做你需要的事情

permutations.forEach(function(permutation) {
    if (checkSpecial(permutation[0], permutation[1], permutation[2], permutation[3])) {

    } else {

    }
});

【讨论】：

【解决方案3】：

这是一个关于 for 循环的想法。将其插入您的 VS

     int a = 0;
     int b = 0;
     int c = 0;
     int d = 0;


     for (a = 0; a <= 1; a++)
     {
        for (b = 0; b <= 1; b++)
        {
           for (c = 0; c <= 1; c++)
           {
              for (d = 0; d <= 1; d++)
              {
                 Console.WriteLine($"function({a}, {b}, {c}, {d})");
              }
           }
        }
     }
     Console.ReadKey();

【讨论】：

【解决方案4】：

function* bin(){
  yield 0;
  yield 1;
}
function* word(size,prefix){
  if(!prefix){
    prefix=[];
  }
  if(size){
    var b=bin(),
        n;
    while((n=b.next()) && !n.done){
      prefix[size-1]=n.value;
      yield* word(size-1,prefix);
    }
  } else {
    yield prefix;
  }
}

var w=word(4),
    cond=true,
    n;
while((n=w.next())&&!n.done){
  if(checkSpecial.apply(n.value)){
    cond=false;
    break;
  }
}

if(cond){

} else {

}

【讨论】：

【解决方案5】：

你可以做一个像这样的for循环..

boolean checkConditions() {
        int[][] cond = {
                {1, 1, 1, 1},
                {1, 1, 1, 0},
                {1, 1, 0, 1},
                {1, 0, 1, 1},
                {0, 1, 1, 1},
                {1, 1, 0, 0},
                {1, 0, 0, 1},
                {0, 0, 1, 1},
                {1, 0, 1, 0},
                {0, 1, 1, 0},
                {0, 1, 0, 1},
                {1, 0, 0, 0},
                {0, 1, 0, 0},
                {0, 0, 1, 0},
                {0, 0, 0, 1},
                {0, 0, 0, 0}};

        for (int i = 0; i < cond.length; i++) {
            if(checkSpecial(cond[i][0], cond[i][1], cond[i][2], cond[i][3])) {
                return false;
            }
        }
        // do other stuff
    }

【讨论】：