Выражение внутри оператора case switch

Вы всегда могли сделать

switch (true) {
  case (amount >= 7500 && amount < 10000):
    //code
    break;
  case (amount >= 10000 && amount < 15000):
    //code
    break;

  //etc...

Это работает, потому что true является константой, поэтому будет выполнен код под первым оператором case с выражением, которое оценивается как истинное.

Я думаю, это довольно "сложно", но я не вижу ничего плохого в его использовании. Простая инструкция if/else, вероятно, будет более лаконичной, и вам не придется беспокоиться о случайном провале. Но так или иначе.

switch (true) @ MooGoo даст вам _ 2_ ошибка в jsLint, так что давайте проявим немного больше творчества на случай, если это проблема, и, я думаю, немного повысим читаемость.

Таким образом, мы не оцениваем, является ли каждый case true или false; мы сравниваем, равно ли значение этого case нашему switch члену. Итак, давайте воспользуемся этим, добавив сокращенное обозначение if в наш case оператор и вернув исходный член переключения, если условие истинно.

Я также привожу своего рода пример из реального мира, где вы хотите иметь два значения по умолчанию - одно, если ваш термин выходит за пределы вашего важного диапазона в положительном направлении, и другой, если вы находитесь в отрицательном направлении.

Ключевая фраза: case (x > 0 ? x : null):

Если мой член x больше нуля, верните x, чтобы x === x и я взяли ветвь case.

http://jsfiddle.net/rufwork/upGH6/1/

/*global document*/
/*jslint evil:true*/
var x = 10;

switch (x) {
    case (x > 0 ? x : null):
        document.write('ha ha ha!  I fooled switch AND jsLint!  Muhahahahaha!');
        break;
    case 0:
        document.write('zero is nothing.');
        break;
    case -1:
        document.write('low');
        break;
    case -2:
        document.write('lower');
        break;
    case -3: 
        document.write('lowest I care about');
        break;
    default: // anything lower than -3.
        document.write('TOO LOW!!!! (unless you cheated and didn\'t use an int)');
}
document.write('<br>done.');

Быстрый ответ на @ Sv443:

Обратите внимание, что переключатель default: говорит: если вы не обманули и не использовали int, и что для короткого замыкания требуется x === x при возврате x.

Но ваша точка зрения является полезным напоминанием о том, что NaN - это единственный случай, когда короткое замыкание неприменимо.

То есть x должен == x закоротить switch и, как сообщает нам MDN, NaN и только NaN будет сравнивать неравно самому себе (двойной или тройной =) .

Это также означает, что при включении значения NaN (и только значения NaN) всегда попадет default в ЛЮБОЙ switch, потому что вы не можете сопоставить его ценность.

Вот полная цитата из MDN :

NaN сравнивает неравное (через ==,! =, === и! ==) с любым другим значением, включая другое значение NaN. Используйте Number.isNaN (). или isNaN (), чтобы наиболее четко определить является ли значение NaN. Или выполните самосравнение: NaN и только NaN будут сравнивать себя неравно.

Вы можете изменить логику default, чтобы проверить, что у вас есть:

isNaN(x) ? document.write ('nan') : document.write('TOO LOW!!!! ...)');

Или вы даже можете стать хипстером, как предлагает MDN (но, пожалуйста, не надо; ^ D):

x !== x ? document.write ('nan') : document.write('TOO LOW!!!! ...)');

Блок switch работает не так. case используется для хранения единственного значения, которое, если оно равно значению в строке switch. if-else утверждения сослужат вам хорошую службу.

Вот некоторая информация о блоке switch.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/switch

Что ж, вы можете использовать выражения в операторе case, поэтому ваш переключатель не является синтаксической ошибкой. Но вы должны понимать, что Case Clause сравнивается с использованием === (строгое сравнение). Как только вы поймете, что значение должно точно совпадать со значением выражения в вашем switch(expression), вы можете поискать выражения в js.

Вызов функций - это выражения, поэтому давайте попробуем с ними:

function xbox(amount) { return amount >= 10000 && amount < 15000 && amount; }

function reward(amount) {
  var ps3 = function(amount) { return amount >= 7500 && amount < 10000 && amount; }

  function imac(amount) { return amount >= 15000 && amount; }

  var $reward = $("#reward");
  switch (amount) {
    case ps3(amount):
      $reward.text("Play Station 3");
      break;
    case xbox(amount):
      $reward.text("XBOX 360");
      break;
    case imac(amount):
      $reward.text("iMac");
      break;
    default:
      $reward.text("No reward");
      break;
  }
}
reward(8200)// -> Play Station 3
reward(11000)// -> XBOX 360
reward(20000)// -> iMac

Как видите, вы можете использовать как выражения функций, так и определения функций. Это не имеет значения. Только то, что выражение в предложении case является выражением для оценки. Это то же самое, что и вы, только вы вернули не значение, которое было таким же, как сумма, а верное или ложное значение. В моем примере я возвращаю точную сумму, если мое условие истинно, поэтому запускаю сравнение для сопоставления.

Вот ваш фиксированный код:

function reward(amount) {
    var $reward = $("#reward");
    switch (amount) {
        case (amount >= 7500 && amount < 10000 && amount):
            $reward.text("Play Station 3");
            break;
        case (amount >= 10000 && amount < 15000 && amount):
            $reward.text("XBOX 360");
            break;
        case (amount >= 15000 && amount):
            $reward.text("iMac");
            break;
        default:
            $reward.text("No reward");
            break;
    }
}

Вот спецификация: https://tc39.github.io/ecma262/#sec-switch-statement Ссылка на es2016, потому что его легче искать, чем старый es3 pdf от 1999 года. Но он всегда работал так, но это малоизвестный факт.

Однако я сомневаюсь, что это быстрее, чем инструкции if. Если вы хотите, чтобы ваша пробежка выполнялась быстро, не прикасайтесь к модели DOM.

Вы также можете попробовать одну из моих любимых конструкций:

function reward(amount) {
    var $reward = $("#reward");
    $reward.text(
        (amount >= 7500 && amount < 10000) ?    "Play Station 3" :
        (amount >= 10000 && amount < 15000)?    "XBOX 360" :
        (amount >= 15000) ?                     "iMac" :
                                                "No reward"
    );
}

Во-первых, switch работает не так. Вы должны указать константы для каждого case, и эти константы будут сравниваться с выражением в круглых скобках (в вашем случае amount). Вот как работает switch, точка.

Во-вторых, переключение происходит не быстрее нескольких ifсек.

И в-третьих, вам не стоит особо беспокоиться о незначительной оптимизации производительности, когда вы имеете дело с javascript.

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

Решение, в котором для выражения switch установлено значение true, работает не потому, что true является константой, а потому, что фактически возможно равенство с выражениями case.

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

Чтобы подтвердить мой ответ, обратитесь к Дугласу Крокфорду, Javascript The Good Parts (2008), стр. 12:

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

Мои 2 цента:

В идеале switch (как правило) должен оцениваться в одну ветвь case, тем самым достигая производительности O (1), и (кроме случаев пропадания) операторы case могут быть переупорядочены любым способом без изменения стратегии ветвления компилятора.

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

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

Пример:

var x = 6, factors = [];

switch(x){

    case (x%2 == 0): factors.push(2);
    break;

    case (x%3 == 0): factors.push(3);
    break;
    ....
 }

{Ожидайте комментариев по поводу некачественного кода}

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

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