Як скоротити мої умовні твердження

У мене є дуже довгий умовний вислів, наприклад наступний:

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методу, ви можете використовувати цю поліфункцію .

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

Оновлення. Оскільки тепер у нас є 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. Див. Вище). Зауважте, що під inArrayчас обміну підписом методу PHP jQuery насправді імітує нативну 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"s" по всій.

Отже, все це було довготривалим способом сказати, що ~nповернеться лише 0тоді, якщо nє -1.

Ви можете використовувати оператор переключення з падіння через:

switch (test.type) {

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

Використовуючи Science: ви повинні робити те, що сказав 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(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 цілі, коли пишеться така умова if.

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...
}

Це не так швидко, як оператор перемикання / випадку і трохи більш багатослівний, ніж деякі інші приклади, але я часто отримую повторне використання об'єкта в іншому місці коду, що може бути дуже зручним.

Piggybacking на одному з зразків 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 для запуску, а третій розділ, щоб змусити цикл з часом вийти.