是否有更好的方法来比较3个值，可能是或可能不是0在Javascript?

Question

我试图比较3个不同的值，可能是0或更大。唯一的方法是使用多个else-if语句吗?这就是我现在所拥有的，但我只是觉得一定有更好的方法:

//just A
if (A > 0 && B == 0 && C == 0){//Do something}
//just B
else if (A == 0 && B > 0 && C == 0){//Do something}
//just C
else if (A == 0 && B == 0 && C > 0){//Do something}
//A + B
else if (A > 0 && B > 0 && C == 0){//Do something}
//A + C
else if (A > 0 && B == 0 && C > 0){//Do something}
//B + C
else if (A == 0 && B > 0 && C > 0){//Do something}
//A + B + C
else if (A > 0 && B > 0 && C > 0){//Do something}
else {//Do something}

Answer 1

您可以认为每个单独的检查产生的值为1或0 (true或false)。如果测试值为A=2, B=0, C=99，则检查A > 0->真正的→1和B == 0->假→

0。因此，如果我们将A, B和C的三种检查的每种变化结合起来，测试值的结果如下:

• none:A == 0 && B == 0 && C == 0->假，假，假->000
• just A:A > 0 && B == 0 && C == 0->真，假，假->100
• just C:A == 0 && B == 0 && C > 0->假，假，真->001
• just B:A == 0 && B > 0 && C == 0->假，真，假->010
• B + C:A == 0 && B > 0 && C > 0->假，真，真->011
• A + C:A > 0 && B == 0 && C > 0->真，假，真->101
• A + B:A > 0 && B > 0 && C == 0->真，真，假->110
• A + B + C:A > 0 && B > 0 && C > 0->对，对，对->111

您可以使用二进制数字作为对象的键，从中获取您想要执行的操作。这是示例中的variants对象。您可以更换控制台。日志与实际的'做某事'逻辑你需要。

const key = (+!!A << 2) + (+!!B << 1) + !!C;的作用:

1. 将每个数字转换为布尔值-!!A->true,!!B->false(对于测试值(A=2, B=0, C=99)
2. 将布尔值转换为数字-+true->1、+false->0
3. 将其移位到合适的位位置-1<<2->100(二进制)->4(十进制)，0<<1仍为0，
4. 将数字相加- 4 + 0 + 1 ->5→0 b101

const variants = {
[0b000]() {console.log('none/default')},
[0b001]() {console.log('just C')},
[0b010]() {console.log('just B')},
[0b011]() {console.log('B+C')},
[0b100]() {console.log('just A')},
[0b101]() {console.log('A+C')},
[0b110]() {console.log('A+B')},
[0b111]() {console.log('A+B+C')},
}
const A = 2;
const B = 0;
const C = 99;
const key = (+!!A << 2) + (+!!B << 1) + !!C;
variants[key]();

选项2

如果使用二进制数和按位操作感到困惑，可以使用字符串表示二进制数。

const variants = {
'000': () => {console.log('none/default')},
'010': () => {console.log('just B')},
// the rest of the keys
}
const bitA = A ? 1 : 0;
const bitB = B ? 1 : 0;
const bitC = C ? 1 : 0;
const key = `${bitA}${bitB}${bitC}`;
variants[key]();

Answer 2

你有3个变量(a, b, c)和2个可能的(>0或<= 0)状态，这意味着您总共有2³= 8种情况。一种方法是将它们表示为位

const toBits = (a, b, c) = {
const toBit = val => val > 0 ? '1' : '0'
return toBit(a) + toBit(b) + toBit(c)
}
const cases = {
'000': () => { // do something },
'001': () => { // do something },
'010': () => { // do something },
'011': () => { // do something },
'100': () => { // do something },
'101': () => { // do something },
'110': () => { // do something },
'111': () => { // do something },
}
const bitsRepresentation = toBits(a, b, c)
const runCase = cases[bitsRepresentation]
runCase()

另一种选择是用反向方式使用switch

const aFlag = a > 0
const bFlag = b > 0
const cFlag = c > 0
switch (true) {
case (!aFlag && !bFlag && !cFlag):
// do something  
case (!aFlag && !bFlag && cFlag):
// do something  
case (!aFlag && bFlag && !cFlag):
// do something  
case (!aFlag && bFlag && cFlag):
// do something  
case (aFlag && !bFlag && !cFlag):
// do something  
case (aFlag && !bFlag && cFlag):
// do something  
case (aFlag && bFlag && !cFlag):
// do something  
case (aFlag && bFlag && cFlag):
// do something  
default:
// do nothing
}

Answer 3

这真的取决于你是否真的需要严格区分所有这8种情况，但如果你仍然需要所有这8种情况，我想你可以检查一次a, b和c，并将它们分配给布尔值，而不是反复检查它们:

aFlag = (A > 0);
bFlag = (B > 0);
cFlag = (C > 0);
//just A
if (aFlag && !bFlag && !cFlag){//Do something}
//just B
else if (!aFlag && bFlag && !cFlag){//Do something}
//just C
else if (!aFlag && !bFlag && cFlag){//Do something}
//A + B
else if (aFlag && bFlag && !cFlag){//Do something}
//A + C
else if (aFlag && !bFlag && cFlag){//Do something}
//B + C
else if (!aFlag && bFlag && cFlag){//Do something}
//A + B + C
else if (aFlag && bFlag && cFlag){//Do something}
else {//Do something}

这可能不会快多少，但是，至少在我看来，它看起来更容易看。

我猜你也可以把它改成某种形式的嵌套if语句，而不是一系列线性的else-if语句:

if (A > 0) {
if (B > 0) {
if (C > 0) {
//A + B + C
} else {
//A + B
}
} else {
if (C > 0) {
//A + C
} else {
//just A
}
}
} else {
if (B > 0) {
if (C > 0) {
//B + C
} else {
//just B
}
} else {
if (C > 0) {
//just C
} else {
//None
}
}
}

这看起来真的很乱，但它总共只做3次检查，而不是你实现的可能的7次。

Answer 4

不能减少else if语句，但可以减少每个if条件中的条件。我建议将这三个变量求和，并检查是否有特定值与sum匹配。

我的建议是:

const sum = A + B + C;
//just A
if (A == sum){//Do something
}
//just B
else if (B == sum){//Do something
}
//just C
else if (C == sum){//Do something
}
//A + B
else if (A + B == sum){//Do something
}
//A + C
else if (A + C  == sum){//Do something
}
//B + C
else if (B + C  == sum){//Do something
}
//A + B + C
else if (A + B + C == sum){//Do something
}
else {//Do something
}

根据问题，我假设你有A, B and C是数字，大于或等于0。