Javascript: самый красивый способ сравнить одно значение с несколькими значениями

Ответ 1

Не пытайтесь быть слишком проницательным, особенно когда это бесполезно влияет на производительность. Если у вас действительно есть целая куча сравнений, просто отформатируйте ее красиво.

if (foobar === foo ||
    foobar === bar ||
    foobar === baz ||
    foobar === pew) {
     //do something
}

Ответ 2

То, что я использую, помещает эти несколько значений в массив, например

var options = [foo, bar];

а затем используйте indexOf()

if(options.indexOf(foobar) > -1){
   //do something
}

для красивости:

if([foo, bar].indexOf(foobar) +1){
   //you can't get any more pretty than this :)
}

и для старых браузеров:
(https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/IndexOf)

if (!Array.prototype.indexOf) {
    Array.prototype.indexOf = function (searchElement /*, fromIndex */ ) {
        "use strict";
        if (this == null) {
            throw new TypeError();
        }
        var t = Object(this);
        var len = t.length >>> 0;
        if (len === 0) {
            return -1;
        }
        var n = 0;
        if (arguments.length > 0) {
            n = Number(arguments[1]);
            if (n != n) { // shortcut for verifying if it NaN
                n = 0;
            } else if (n != 0 && n != Infinity && n != -Infinity) {
                n = (n > 0 || -1) * Math.floor(Math.abs(n));
            }
        }
        if (n >= len) {
            return -1;
        }
        var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);
        for (; k < len; k++) {
            if (k in t && t[k] === searchElement) {
                return k;
            }
        }
        return -1;
    }
}

Ответ 3

Просто для пинков, так как это Q & A, похоже, связано с синтаксическим микроанализом, крошечной крошечной модификацией предложений Андре Альшады Падез:

(и, конечно же, он учитывает предустановленный IE9 shim/shiv/ polyfill)

if (~[foo, bar].indexOf(foobar)) {
    // pretty
}

Ответ 4

Вы можете использовать переключатель:

switch (foobar) {
  case foo:
  case bar:
    // do something
}

Ответ 5

Поскольку никто не добавил очевидное решение, которое отлично работает для двух сравнений, я предлагаю его:

if (foobar == foo || foobar == bar) {
     //do something
}

И, если у вас много значений, я бы предложил сделать Set, поскольку это делает очень чистый и простой код сравнения, и он быстро выполняется во время выполнения:

// pre-construct the Set
var tSet = new Set([foo, bar, test1, test2, test3]);

// test the Set at runtime
if (tSet.has(foobar)) {
    // do something
}

Для pre-ES6 вы можете получить Set polyfill, которого много. Один из них описан в этом другом ответе.

Ответ 6

Почему бы не использовать indexOf из массива вроде ниже?

if ([foo, bar].indexOf(foobar) !== -1) {
    // do something
}

Просто простой Javascript, никаких фреймворков или библиотек, но он будет not работать над IE < 9.

Ответ 7

Мне нравится симпатичная форма тестирования indexOf с массивом, но имейте в виду, что это не работает во всех браузерах (потому что Array.prototype.indexOf отсутствует в старых IExplorers).

Однако аналогичный способ можно использовать с помощью jQuery с функцией $. inArray():

if ($.inArray(field, ['value1', 'value2', 'value3']) > -1) {
    alert('value ' + field + ' is into the list'); 
}

Это может быть лучше, поэтому вам не следует проверять, существует ли indexOf.

Будьте внимательны при сравнении (не используйте == true/false), потому что $.inArray возвращает индекс совпадающей позиции, где значение найдено, а если индекс равен 0, это было бы неверно, если действительно существуют в массиве.

Ответ 8

(foobar == foo || foobar == bar) В противном случае, если вы сравниваете выражения, основанные только на одном целочисленном, перечисляемом значении или объекте String, вы можете использовать переключатель. См. Заявление о переключении. Вы также можете использовать метод, предложенный Андре Альшадой Падезом. В конечном итоге то, что вы выбираете, должно зависеть от деталей того, что вы делаете.

Ответ 9

Метод переключения (как упоминается Гуффа) работает очень хорошо. Тем не менее, настройки предупреждения по умолчанию в большинстве линтеров будут предупреждать вас об использовании провала. Это одна из основных причин, по которой я вообще использую коммутаторы, поэтому я почти игнорирую это предупреждение, но вы должны знать, что использование сквозной функции оператора switch может быть сложным. В таких случаях, хотя это - я бы пошел на это.