Как сократить мои условные высказывания

У меня есть очень длинное условное утверждение, подобное следующему:

if(test.type == 'itema' || test.type == 'itemb' || test.type == 'itemc' || test.type == 'itemd'){
    // do something.
}

Мне было интересно, смогу ли я переформулировать это выражение / утверждение в более сжатую форму.

Есть идеи, как этого добиться?

Поместите ваши значения в массив и проверьте, находится ли ваш элемент в массиве:

if ([1, 2, 3, 4].includes(test.type)) {
    // Do something
}

Если браузер, который вы поддерживаете, не имеет Array#includesметода, вы можете использовать этот polyfill .

Краткое объяснение ~ярлыка тильды:

Обновить: как у нас теперь есть includesметод, нет смысла использовать ~взломать больше. Просто оставьте это здесь для людей, которые заинтересованы в знании того, как это работает и / или столкнулись с этим в чужом коде.

Вместо проверки, если результат indexOf есть >= 0, есть хороший маленький ярлык:

if ( ~[1, 2, 3, 4].indexOf(test.type) ) {
    // Do something
}

Вот скрипка: http://jsfiddle.net/HYJvK/

Как это работает? Если элемент найден в массиве, indexOfвозвращает его индекс. Если предмет не был найден, он вернется -1. Не вдаваясь в подробности, ~это побитовый оператор НЕ , который вернет0 только для -1.

Мне нравится использовать ~ярлык, поскольку он более лаконичен, чем сравнение возвращаемого значения. Хотелось бы, чтобы в JavaScript была in_arrayфункция, которая возвращала бы логическое значение напрямую (аналогично PHP), но это просто желаемое за действительное ( Обновление: теперь это происходит. Это называется includes. Смотрите выше) Обратите внимание, что jQuery inArray, разделяя сигнатуру метода PHP, фактически имитирует нативную indexOfфункциональность (которая полезна в разных случаях, если индекс - это то, что вам действительно нужно).

Важное примечание: использование ярлыка тильды, похоже, обернулось спорами, как некоторые яростно полагают, что код недостаточно ясен и его следует избегать любой ценой (см. Комментарии к этому ответу). Если вы разделяете их мнение, вы должны придерживаться .indexOf(...) >= 0решения.

Немного более длинное объяснение:

Целые числа в JavaScript подписаны, что означает, что самый левый бит зарезервирован как бит знака; флаг, чтобы указать, является ли число положительным или отрицательным, с1 отрицательным.

Вот некоторые примеры положительных чисел в 32-битном двоичном формате:

1 :    00000000000000000000000000000001
2 :    00000000000000000000000000000010
3 :    00000000000000000000000000000011
15:    00000000000000000000000000001111

Теперь вот те самые цифры, но отрицательные:

-1 :   11111111111111111111111111111111
-2 :   11111111111111111111111111111110
-3 :   11111111111111111111111111111101
-15:   11111111111111111111111111110001

Почему такие странные комбинации для отрицательных чисел? Просто. Отрицательное число - это просто инверсия положительного числа + 1; добавление отрицательного числа к положительному числу должно всегда давать0 .

Чтобы понять это, давайте сделаем простую двоичную арифметику.

Вот как мы могли бы добавить -1к +1:

   00000000000000000000000000000001      +1
+  11111111111111111111111111111111      -1
-------------------------------------------
=  00000000000000000000000000000000       0

А вот как мы могли бы добавить -15к +15:

   00000000000000000000000000001111      +15
+  11111111111111111111111111110001      -15
--------------------------------------------
=  00000000000000000000000000000000        0

Как мы получаем эти результаты? Выполняя регулярное сложение, как нас учили в школе: вы начинаете с самого правого столбца и складываете все строки. Если сумма больше наибольшего однозначного числа (которое в десятичном виде 9, но в двоичном1 ), мы переносим остаток в следующий столбец.

Теперь, как вы заметите, при добавлении отрицательного числа к его положительному номеру, самый правый столбец, который не является всем 0s, всегда будет иметь два 1s, которые при сложении вместе приведут к 2. Двоичное представление двух существ 10, мы переносим в 1следующий столбец и помещаем 0результат в первый столбец. Все остальные столбцы слева имеют только одну строку с символом «a» 1, поэтому перенос 1из предыдущего столбца будет снова складываться 2, что затем будет перенесено ... Этот процесс повторяется до тех пор, пока мы не доберемся до самого левого столбца, где « 1Переносить» некуда, поэтому он переполняется и теряется, и мы остаемся со 0всеми.

Эта система называется дополнением 2 . Вы можете прочитать больше об этом здесь:

Представление дополнения 2 для подписанных целых чисел .

Теперь, когда ускоренный курс в дополнении 2 закончен, вы заметите, что -1это единственное число, двоичное представление которого1 повсюду.

Используя ~побитовый оператор NOT, все биты в данном номере инвертируются. Единственный способ 0вернуться от инвертирования всех битов, если мы начали с1 все сначала.

Итак, все это было многословным способом сказать, что ~nвернется, только 0если nесть -1.

Вы можете использовать оператор switch с fall thru:

switch (test.type) {

  case "itema":
  case "itemb":
  case "itemc":
  case "itemd":
    // do something
}

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

Это быстрее, чем ~метод

var x = test.type;
if (x == 'itema' ||
    x == 'itemb' ||
    x == 'itemc' ||
    x == 'itemd') {
    //do something
}

http://jsperf.com/if-statements-test-techsin (Верхний набор: Chrome, нижний набор: Firefox)

Вывод :

Если возможности мало , и вы знаете , что некоторые из них являются более вероятны , чем вы получаете максимальную производительность из if ||, switch fall throughиif(obj[keyval]) .

Если возможностей много , и любой из них может быть самым распространенным, другими словами, вы не можете знать, какой из них наиболее вероятен, чем вы получаете наибольшую производительность из поиска объектов if(obj[keyval])иregex соответствует ли он.

http://jsperf.com/if-statements-test-techsin/12

Я буду обновлять, если что-то новое появится.

Если вы сравниваете со строками и существует шаблон, рассмотрите возможность использования регулярных выражений.

В противном случае, я подозреваю, что попытка сократить его просто запутает ваш код. Попробуйте просто обернуть строки, чтобы сделать его красивым.

if (test.type == 'itema' ||
    test.type == 'itemb' ||
    test.type == 'itemc' ||
    test.type == 'itemd') {
    do something.
}

var possibilities = {
  "itema": 1,
  "itemb": 1,
  "itemc": 1,
…};
if (test.type in possibilities) { … }

Использование объекта в качестве ассоциативного массива - довольно распространенная вещь, но, поскольку у JavaScript нет собственного набора, вы также можете использовать объекты в качестве дешевых наборов.

if( /^item[a-d]$/.test(test.type) ) { /* do something */ }

или если предметы не одинаковы, то:

if( /^(itema|itemb|itemc|itemd)$/.test(test.type) ) { /* do something */ }

Отличные ответы, но вы можете сделать код гораздо более читабельным, поместив один из них в функцию.

Это сложный оператор if, когда вы (или кто-то еще) прочитали код в течение нескольких лет, вы будете просматривать этот раздел, чтобы понять, что происходит. Заявление с таким уровнем бизнес-логики заставит вас запнуться на несколько секунд, пока вы решаете, что тестируете. Где, как этот код, позволит вам продолжить сканирование.

if(CheckIfBusinessRuleIsTrue())
{
    //Do Something
}

function CheckIfBusinessRuleIsTrue() 
{
    return (the best solution from previous posts here);
}

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

Вы можете поместить все ответы в набор Javascript, а затем просто вызвать .contains()его.

Вы все равно должны объявить все содержимое, но встроенный вызов будет короче.

Что-то вроде:

var itemSet = new Set(["itema","itemb","itemc","itemd"]);
if( itemSet.contains( test.type ){}

Один из моих любимых способов сделать это с помощью библиотеки, например underscore.js ...

var isItem = _.some(['itema','itemb','itemc','itemd'], function(item) {
    return test.type === item;
});

if(isItem) {
    // One of them was true
}

http://underscorejs.org/#some

другой путь или другой удивительный способ, который я нашел, это ...

if ('a' in oc(['a','b','c'])) { //dosomething }

function oc(a)
{
  var o = {};
  for(var i=0;i<a.length;i++)  o[a[i]]='';
  return o;
}

конечно, как вы можете видеть, это делает вещи на шаг впереди и облегчает их следование логике.

http://snook.ca/archives/javascript/testing_for_a_v

используя операторы, такие как ~ && || ((), ()) ~~ хорошо, только если ваш код сломается позже. Вы не будете знать, с чего начать. Так что читабельность БОЛЬШАЯ.

если вам нужно, вы можете сделать его короче.

('a' in oc(['a','b','c'])) && statement;
('a' in oc(['a','b','c'])) && (statements,statements);
('a' in oc(['a','b','c']))?statement:elseStatement;
('a' in oc(['a','b','c']))?(statements,statements):(elseStatements,elseStatements);

и если вы хотите сделать обратное

('a' in oc(['a','b','c'])) || statement;

Просто используйте switchутверждение вместо ifутверждения:

switch (test.type) {

  case "itema":case "itemb":case "itemc":case "itemd":
    // do your process
  case "other cases":...:
    // do other processes
  default:
    // do processes when test.type does not meet your predictions.
}

Switch также работает быстрее, чем сравнение множества условий в if

Для очень длинных списков строк эта идея сохранит несколько символов (не говоря уже о том, что я бы порекомендовал его в реальной жизни, но он должен работать).

Выберите символ, который, как вы знаете, не встречается в вашем test.type, используйте его в качестве разделителя, вставьте их в одну длинную строку и найдите:

if ("/itema/itemb/itemc/itemd/".indexOf("/"+test.type+"/")>=0) {
  // doSomething
}

Если ваши строки окажутся более жесткими, вы можете даже опустить разделители ...

if ("itemaitembitemcitemd".indexOf(test.type)>=0) {
  // doSomething
}

... но вы должны быть осторожны с ложными срабатываниями в этом случае (например, "embite" будет соответствовать в этой версии)

Для удобства чтения создайте функцию для теста (да, функцию из одной строки):

function isTypeDefined(test) {
    return test.type == 'itema' ||
           test.type == 'itemb' ||
           test.type == 'itemc' ||
           test.type == 'itemd';
}

тогда назовите это:

…
    if (isTypeDefined(test)) {
…
}
...

Я думаю, что есть 2 цели при написании этого условия.

1. краткость
2. читабельность

Таким образом, иногда # 1 может быть самым быстрым, но я возьму № 2 для удобства обслуживания позже. В зависимости от сценария я часто выбираю вариант ответа Уолтера.

Для начала у меня есть глобально доступная функция как часть моей существующей библиотеки.

function isDefined(obj){
  return (typeof(obj) != 'undefined');
}

и затем, когда я действительно хочу выполнить условие if, подобное вашему, я бы создал объект со списком допустимых значений:

var validOptions = {
  "itema":1,
  "itemb":1,
  "itemc":1,
  "itemd":1
};
if(isDefined(validOptions[test.type])){
  //do something...
}

Это не так быстро, как оператор switch / case, и немного более многословно, чем некоторые другие примеры, но я часто получаю повторное использование объекта в другом месте кода, что может быть очень удобно.

В сочетании с одним из образцов jsperf, сделанных выше, я добавил этот тест и вариацию для сравнения скоростей. http://jsperf.com/if-statements-test-techsin/6 Самое интересное, что я заметил, это то, что некоторые тестовые комбинации в Firefox выполняются намного быстрее, чем даже Chrome.

Это можно решить с помощью простого цикла:

test = {};
test.type = 'itema';

for(var i=['itema','itemb','itemc']; i[0]==test.type && [
    (function() {
        // do something
        console.log('matched!');
    })()
]; i.shift());

Мы используем первый раздел цикла for, чтобы инициализировать аргументы, которые вы хотите сопоставить, второй раздел, чтобы остановить цикл for, и третий раздел, чтобы в конечном итоге завершить цикл.