Kiedy spojrzałem na rozwiązania w innych odpowiedziach zobaczyłem pewne rzeczy, które Wiem, że są złe dla wydajności. Miałem zamiar umieścić je w komentarzu, ale pomyślałem, że lepiej jest porównać go i podzielić się wynikami. Możesz przetestować go samodzielnie. Poniżej znajdują się moje wyniki (ymmv) znormalizowane po najszybszej operacji w każdej przeglądarce (pomnóż czas 1.0 z znormalizowaną wartością, aby uzyskać czas bezwzględny w ms).

                    Chrome  Firefox Opera   MSIE    Safari  Node
-------------------------------------------------------------------
1.0 time               37ms    73ms    68ms   184ms    73ms    21ms
if-immediate            1.0     1.0     1.0     2.6     1.0     1.0
if-indirect             1.2     1.8     3.3     3.8     2.6     1.0
switch-immediate        2.0     1.1     2.0     1.0     2.8     1.3
switch-range           38.1    10.6     2.6     7.3    20.9    10.4
switch-range2          31.9     8.3     2.0     4.5     9.5     6.9
switch-indirect-array  35.2     9.6     4.2     5.5    10.7     8.6
array-linear-switch     3.6     4.1     4.5    10.0     4.7     2.7
array-binary-switch     7.8     6.7     9.5    16.0    15.0     4.9

Test gdzie wykonywane na Windows 7 32bit z following versions: Chrome 21.0.1180.89 m, Firefox 15.0, Opera 12.02, MSIE 9.0.8112, Safari 5.1.7 . Node został uruchomiony na 64-bitowym Linuksie, ponieważ rozdzielczość timera na węźle.js Dla Windows był 10ms zamiast 1ms.

If-immediate

Jest to najszybsze we wszystkich testowanych środowiskach, z wyjątkiem ... MSIE! (niespodzianka, niespodzianka). Jest to zalecany sposób realizacji to.

if (val < 1000) { /*do something */ } else
if (val < 2000) { /*do something */ } else
...
if (val < 30000) { /*do something */ } else

If-indirect

Jest to wariant switch-indirect-array, ale zamiast tego z if-statements i działa znacznie szybciej niż switch-indirect-array w prawie wszystkich testowanych środowiskach.

values=[
   1000,  2000, ... 30000
];
if (val < values[0]) { /* do something */ } else
if (val < values[1]) { /* do something */ } else
...
if (val < values[29]) { /* do something */ } else

Switch-immediate

Jest to dość szybkie we wszystkich testowanych środowiskach, a właściwie najszybsze w MSIE. Działa, gdy można wykonać obliczenia, aby uzyskać indeks.

switch (Math.floor(val/1000)) {
  case 0: /* do something */ break;
  case 1: /* do something */ break;
  ...
  case 29: /* do something */ break;
}

Switch-range

Jest to około 6 do 40 razy wolniejsze niż najszybsze we wszystkich testowanych środowiskach z wyjątkiem dla Opery, gdzie trwa około półtora raza dłużej. Jest powolny, ponieważ silnik musi porównać wartość dwukrotnie dla każdego przypadku. Zaskakujące jest to, że Chrome zajmuje prawie 40 razy więcej czasu w porównaniu z najszybszą operacją w Chrome, podczas gdy MSIE zajmuje tylko 6 razy więcej czasu. Ale rzeczywista różnica czasu była tylko 74ms na korzyść MSIE w 1337ms (!).

switch (true) {
  case (0 <= val &&  val < 1000): /* do something */ break;
  case (1000 <= val &&  val < 2000): /* do something */ break;
  ...
  case (29000 <= val &&  val < 30000): /* do something */ break;
}

Switch-range2

Jest to wariant switch-range, ale z tylko jednym porównaniem na przypadek i dlatego szybciej, ale nadal bardzo wolno, z wyjątkiem Opery. Kolejność instrukcji case jest ważna, ponieważ silnik będzie testował każdy przypadek w kolejności kodu źródłowego ECMAScript262:5 12.11

switch (true) {
  case (val < 1000): /* do something */ break;
  case (val < 2000): /* do something */ break;
  ...
  case (val < 30000): /* do something */ break;
}

Switch-indirect-array

W tym wariancie zakresy są przechowywane w tablicy. Jest to powolne we wszystkich testowanych środowiskach i bardzo powolne w Chrome.

values=[1000,  2000 ... 29000, 30000];

switch(true) {
  case (val < values[0]): /* do something */ break;
  case (val < values[1]): /* do something */ break;
  ...
  case (val < values[29]): /* do something */ break;
}

Array-linear-search

Jest to kombinacja liniowego wyszukiwania wartości w tablicy i przełącznika oświadczenie z stałe wartości. Powodem, dla którego ktoś może chcieć tego użyć, jest to, że wartości są znane dopiero w trybie runtime. Jest powolny w każdym testowanym środowisku i trwa prawie 10 razy dłużej w MSIE.

values=[1000,  2000 ... 29000, 30000];

for (sidx=0, slen=values.length; sidx < slen; ++sidx) {
  if (val < values[sidx]) break;
}

switch (sidx) {
  case 0: /* do something */ break;
  case 1: /* do something */ break;
  ...
  case 29: /* do something */ break;
}

Array-binary-switch

Jest to wariant array-linear-switch, ale z przeszukiwaniem binarnym. Niestety jest to wolniejsze niż wyszukiwanie liniowe. Nie wiem, czy to moja implementacja, czy wyszukiwanie liniowe jest bardziej zoptymalizowane. Możliwe, że przestrzeń kluczy jest zbyt mała.

values=[0, 1000,  2000 ... 29000, 30000];

while(range) {
  range = Math.floor( (smax - smin) / 2 );
  sidx = smin + range;
  if ( val < values[sidx] ) { smax = sidx; } else { smin = sidx; }
}

switch (sidx) {
  case 0: /* do something */ break;
  ...
  case 29: /* do something */ break;
}

Podsumowanie

Jeśli wydajność jest ważna, użyj instrukcji if-lub switch z natychmiastowymi wartościami.