Javascript 如何简化嵌套if语句树

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

该函数只返回true或false

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

for（var i=0；i<16；i++）{
//救命啊！
}

---

任何指点都将不胜感激。谢谢。

您可以创建一个数字0-15的二进制表示数组，然后在调用以数组项为参数的函数时检查

是否每个
返回false：


const combines=Array.from(
{长度：16}，
（？，i）=>（i>>>0）.toString（2）.padStart（4，'0'）.split（''）.map（数字）
);
console.log（组合）
/*
if（combinations.every（combination=>checkSpecial（…combination）==false））{
//每个结果都是假的
}否则{
//至少有一个结果不是假的
}
*/
我唯一的建议如下：

使用每个排列初始化数组

var置换=[
[0, 1, 1, 0],
[1, 1, 1, 0]
];下面是一个关于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(); 

inta=0；
int b=0；
int c=0；
int d=0；
对于（a=0；a
函数*bin（）{
产量0；
产量1；
}
函数*字（大小、前缀）{
如果（！前缀）{
前缀=[]；
}
如果（尺寸）{
var b=bin（），
N
而（（n=b.next（））&&！n.done）{
前缀[size-1]=n.value；
产量*字（大小1，前缀）；
}
}否则{
产量前缀；
}
}
var w=单词（4），
cond=true，
N
而（（n=w.next（））&&&！n.done）{
如果（勾选特殊应用（n值））{
cond=假；
打破
}
}
如果（秒）{
}否则{
}
您可以创建类似这样的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
    }

boolean检查条件（）{
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
1.将
i
转换为4位，以1和0的形式存储在数组中。2.使用
函数。原型。应用
而不查看函数的功能。提供建议非常困难。我不知道知道函数的功能有多重要。它请求4个1或0的输入，然后给出正确或错误的答案。尽管如此，函数除了总是返回false之外什么也做不了……关键是我如何简化if语句。正如@Pointy所说，在不知道函数实现了什么的情况下，很难提供任何可靠的结果。我能提供的唯一建议是将每个排列存储在数组中，并对其进行迭代，而不是编写每个if语句。可以吗u一旦一个调用返回true就中止？这会复制一些值（例如，
[1,0,0,0]
）