是"；如果；或；开关"；更好的Javascript

我正在构建一个函数，该函数在运行代码块之前验证用户的输入在应用程序上下文中是否有意义。我想知道像这样的“if…else”语句或switch语句是否能更可靠地工作/否则是更好的解决方案？我倾向于if…else，因为我只有两个结果——用户的输入要么有效，要么告诉用户程序将接受什么，但在我参与之前，我希望得到更有经验的人的建议

编辑：为了清楚起见，我只希望我的代码在I和o都是“a”或“b”，或者都是“c”或“d”，或者都是“e”或“f”时执行

---

另外，在这种情况下，我是否正确地处理了布尔运算符？

首先，您的

if

语句是错误的，因为JavaScript布尔表达式被强制为布尔值

意思是：

'a'  ||  'b'

将始终返回

'a'

，因为

'a'

的计算结果为

true

，JS引擎无需检查

|

语句的第二个操作数

因此，您的

if

语句应该如下所示：

if(((i == "a" || i == "b") && (o == "a" || o == "b")) ||
   ((i == "c" || i == "d") && (o == "c" || o == "d")) ||
   ((i == "e" || i == "f") && (o == "e" || o == "f"))

---

您可以尝试下面这样一个简单的解决方案，而不是使用太多或…和块（可能会使其无法读取）

在这个解决方案中，我们首先创建一个允许值的映射，对于每个值，第二个变量的允许组合是什么，然后我们检查映射中是否存在

a

的值，如果存在，那么我们检查

i

的值是否是允许组合中的允许值

功能测试（a，i）{
变量映射={
a:[a'，b']，
b:[a'，b']，
c:['c'，'d']，
d:['c'，'d']，
e:['e'，'f']，
f:['e'，'f']
};
if（map[a]&&map[a].indexOf（i）>-1）{
log（'found'，a，i，result==true）
}否则{
log（'notfound'，a，i，result==false）
}
}

首先，Javascript不起作用，因为非空字符串的计算结果为

true

，所以

（“c”|“d”）

的计算结果为“c”。这意味着您当前正在检查的是

i

和

o

是相同的值

事实上，这实际上涵盖了您需要的案例的一半（如果

i

和

o

相等，那么无论它们是

“a”

，

“b”

，等等，您都可以继续进行）

您需要的逻辑是：

if( ((i == "a" || i == "b") && (o == "a" || o == "b")) ||
    ((i == "c" || i == "d") && (o == "c" || o == "d")) ||
    ((i == "e" || i == "f") && (o == "e" || o == "f"))
){
    // valid
} else {
    // invalid
}

我更喜欢那种

if

语句，而不是您最终可能遇到的复杂的

开关

你也可以这样做。您意识到
i
和
o
之间只能相差一个字母，因此您可以编写这种逻辑：

if( Math.abs(i.charCodeAt(0) - o.charCodeAt(0)) <= 1 ){
    // valid
} else {
    // invalid
}

您也可以这样做：

var i='a', o='b', 
    allowed = [['a','b'], ['c', 'd'], ['e', 'f']];
function test(one, two) { 
    return allowed.some(function(elem) {
        return (elem.indexOf(one)>=0 && elem.indexOf(two)>=0);
    });
}
console.log(test(i, o));

创建一个包含所有允许值对的数组，然后使用该数组测试
i
和
o
是否在允许值范围内
.some（）
将对数组中存在的每个元素执行一次回调函数，直到找到回调返回真值的元素为止。如果找到这样的元素，它将立即返回true

这里有一个片段：


//仅适用于此代码段
console.log=函数（txt）{
var result=document.getElementById（“结果”）；
result.innerText+=txt+“，”；
}
//允许值
变量i、o、allowed=[[a'、[b']、[c'、[d']、[e'、[f']；
//测试功能
功能测试（一，二）{
允许返回。一些（函数（elem）{
返回值（元素索引（一）>=0和元素索引（二）>=0）；
});
}
//所有测试
i='a'；o='b'；
日志（测试（i，o））；
i='c'；o='d'；
日志（测试（i，o））；
i='e'；o='f'；
日志（测试（i，o））；
i='a'；o='c'；
日志（测试（i，o））；
i='d'；o='e'；
日志（测试（i，o））；
i='x'；o='y'；
日志（测试（i，o））
不，这不起作用，因为
（“c”| |“d”）
只计算为
“c”
。这是所有检查的情况。你需要这样：
（（i==“a”| i==“b”）和&（o==“a”| o==“b”）
。这比使用switch更具可读性。避免主要基于观点的问题，或者可能产生讨论而不是答案的问题。这是一个有趣的解决方案。试着解释一下它是如何工作的，如何使用，并在代码中添加一些注释。当我更改了我的代码，它现在正在运行时，你能解释一下你的意思吗？您是将预期值映射到二维数组，然后检查它们是否存在，还是完全丢失了？
check("a", "a")
// true
check("a", "b")
// true
check("a", "c")
// false
check("e", "f")
// true
check("a", "a")
// true
check("b", "a")
// true

var i='a', o='b', 
    allowed = [['a','b'], ['c', 'd'], ['e', 'f']];
function test(one, two) { 
    return allowed.some(function(elem) {
        return (elem.indexOf(one)>=0 && elem.indexOf(two)>=0);
    });
}
console.log(test(i, o));