JavaScript/Node.JS - 使用 OR 运算符的紧凑方式？

Question

假设我有一个检查字符串的情况。我需要检查它是否匹配 a 或匹配 b。现在，当然，我可以做

var firstVar = "a"
var secondVar = "b"
var message = "atest" // note that I might not know what message is. it could be anything. it could be just "test" or just "a"
if ((message === firstVar + "test") || (message === secondVar + "test")) {
   console.log("success!")
}

但是有什么办法可以压缩它吗？与 myVar 相关的事情是一个具有 a 和 b 值的数组，然后检查 message 是否以 任何值开始在 myVar？如果有人有小费，那将不胜感激。谢谢！

Answer 1

傻：

var vars = ["a", "b"].map(function(v) {
  return v + "test";
});
var message = "atest";
if (vars.indexOf(message) > -1) {
   console.log("success!");
}

中心：

var vars = ["a", "b"].map(v => v + "test");
var message = "atest";
if (vars.includes(message)) {
   console.log("success!");
}

Answer 2

使用includes；根据您的修改：

const allowed = ['a','b','ccc'];

if( allowed.includes(`${ message }test`) ) {
    console.log("success!")
}

Answer 3

使用 include 和 vanilla 的示例

ES6方式

const testArray = [1,2,3];

testArray.includes(1); //returns true
testArray.includes(24); //returns false

ES5方式

var testArray = [1,2,3];
testArray.indexOf(1) // returns 1 since its a member.
testArray.indexOf(43) //returns -1 since it's not a member.

Answer 4

使用带有 some 的数组将是最简单的方法：

var tests = ["a", "b"];
var message = "atest";
if (tests.some(function(t) { return message === t + "test"; })) {
    console.log("success!")
}

如果您可以使用 ES6 并且需要经常运行此检查，那么使用

可能有意义

const choices = new Set(["a", "b"].map(t => t + "test"));
…
var message = "atest";
if (choices.has(message)) {
    console.log("success!")
}

Answer 5

我可能会在前缀数组上使用 Array.prototype.some 然后...:[=30=]

如果前缀都是单个字符，直接做messsage[0] === prefix，这应该是最快的选择（没有函数调用，也没有字符串连接，只是一个简单快速的比较运算符。

const prefixes = ["a", "b"];
const message1 = "atest";
const message2 = "btest";
const message3 = "ctest";

console.log(prefixes.some(prefix => message1[0] === prefix));
console.log(prefixes.some(prefix => message2[0] === prefix));
console.log(prefixes.some(prefix => message3[0] === prefix));

如果前缀可以有多个字符（也适用于单个字符），那么我会做 message.indexOf(prefix) === 0:

const prefixes = ["at", "bt"];
const message1 = "atest";
const message2 = "btest";
const message3 = "ctest";

console.log(prefixes.some(prefix => message1.indexOf(prefix) === 0));
console.log(prefixes.some(prefix => message2.indexOf(prefix) === 0));
console.log(prefixes.some(prefix => message3.indexOf(prefix) === 0));

您还可以构建并使用 RegExp，如果您要多次执行代码（这将对第一次从字符串构建 RegExp，但后来你只是一遍又一遍地重复使用那个字符串）：

如果前缀是单个字符：

const prefixes = ["a", "b"];
const message1 = "atest";
const message2 = "btest";
const message3 = "ctest";

const regexp = new RegExp(`^[${ prefixes.join('') }]`);

console.log(regexp.test(message1))
console.log(regexp.test(message2))
console.log(regexp.test(message3))

如果前缀是多个字符（也适用于单个字符）：

const prefixes = ["at", "bt"];
const message1 = "atest";
const message2 = "btest";
const message3 = "ctest";

const regexp = new RegExp(`^(${ prefixes.join('|') })`);

console.log(regexp.test(message1))
console.log(regexp.test(message2))
console.log(regexp.test(message3))

如果你想检查 message 实际上是任何这些前缀加上其他东西的组合，比如你的例子中的 "test"，那么你可能想要预先计算所有可能的选项:

使用数组（或按照@Bergi 的建议设置）和Array.prototype.includes or Array.prototype.indexOf

const prefixes = ["a", "b"];
const word = "test";
const options = prefixes.map(prefix => `${ prefix }${ word }`);
const message1 = "atest";
const message2 = "btest";
const message3 = "ctest";

console.log(options.includes(message1));
console.log(options.includes(message2));
console.log(options.includes(message3));

console.log(options.indexOf(message1) !== -1);
console.log(options.indexOf(message2) !== -1);
console.log(options.indexOf(message3) !== -1);

使用 RegExp 和 RegExp.prototype.test or String.prototype.match:

const prefixes = ["a", "b"];
const word = "test";
const regexp = new RegExp(`^(${ prefixes.join("|") })${ word }`);
const message1 = "atest";
const message2 = "btest";
const message3 = "ctest";

console.log(regexp.test(message1));
console.log(regexp.test(message2));
console.log(regexp.test(message3));

console.log(!!message1.match(regexp));
console.log(!!message2.match(regexp));
console.log(!!message3.match(regexp));

JavaScript/Node.JS - 使用 OR 运算符的紧凑方式？

JavaScript/Node.JS - compact way of using OR operator?

javascript

variables

var

operators

node.js