If-else vs. switch vs. lookup table (v19)

Revision 19 of this benchmark created on


Setup

function ifElseTest(stuff) {
    
      if (stuff === 0) {
        return 0;
      } else if (stuff === 1) {
        return 1;
      } else if (stuff === 2) {
        return 2;
      } else if (stuff === 3) {
        return 3;
      } else if (stuff === 4) {
        return 4;
      } else if (stuff === 5) {
        return 5;
      } else if (stuff === 6) {
        return 6;
      } else if (stuff === 7) {
        return 7;
      } else if (stuff === 8) {
        return 8;
      } else if (stuff === 9) {
        return 9;
      } else if (stuff === 10) {
        return 10;
      } else if (stuff === 11) {
        return 11;
      } else if (stuff === 12) {
        return 12;
      } else if (stuff === 13) {
        return 13;
      } else if (stuff === 14) {
        return 14;
      } else if (stuff === 15) {
        return 15;
      } else if (stuff === 16) {
        return 16;
      } else if (stuff === 17) {
        return 17;
      } else if (stuff === 18) {
        return 18;
      } else if (stuff === 19) {
        return 19;
      } else if (stuff === 20) {
        return 20;
      } else if (stuff === 21) {
        return 21;
      } else if (stuff === 22) {
        return 22;
      } else if (stuff === 23) {
        return 23;
      } else if (stuff === 24) {
        return 24;
      } else if (stuff === 25) {
        return 25;
      } else if (stuff === 26) {
        return 26;
      } else if (stuff === 27) {
        return 27;
      } else if (stuff === 28) {
        return 28;
      } else if (stuff === 29) {
        return 29;
      } else if (stuff === 30) {
        return 30;
      } else if (stuff === 31) {
        return 31;
      } else if (stuff === 32) {
        return 32;
      } else if (stuff === 33) {
        return 33;
      } else if (stuff === 34) {
        return 34;
      } else if (stuff === 35) {
        return 35;
      } else if (stuff === 36) {
        return 36;
      } else if (stuff === 37) {
        return 37;
      } else if (stuff === 38) {
        return 38;
      } else if (stuff === 39) {
        return 39;
      } else if (stuff === 40) {
        return 40;
      } else if (stuff === 41) {
        return 41;
      } else if (stuff === 42) {
        return 42;
      } else if (stuff === 43) {
        return 43;
      } else if (stuff === 44) {
        return 44;
      } else if (stuff === 45) {
        return 45;
      } else if (stuff === 46) {
        return 46;
      } else if (stuff === 47) {
        return 47;
      } else if (stuff === 48) {
        return 48;
      } else if (stuff === 49) {
        return 49;
      } else if (stuff === 50) {
        return 50;
      } else if (stuff === 51) {
        return 51;
      } else if (stuff === 52) {
        return 52;
      } else if (stuff === 53) {
        return 53;
      } else if (stuff === 54) {
        return 54;
      } else if (stuff === 55) {
        return 55;
      } else if (stuff === 56) {
        return 56;
      } else if (stuff === 57) {
        return 57;
      } else if (stuff === 58) {
        return 58;
      } else if (stuff === 59) {
        return 59;
      } else if (stuff === 60) {
        return 60;
      } else if (stuff === 61) {
        return 61;
      } else if (stuff === 62) {
        return 62;
      } else if (stuff === 63) {
        return 63;
      } else if (stuff === 64) {
        return 64;
      } else if (stuff === 65) {
        return 65;
      } else if (stuff === 66) {
        return 66;
      } else if (stuff === 67) {
        return 67;
      } else if (stuff === 68) {
        return 68;
      } else if (stuff === 69) {
        return 69;
      } else if (stuff === 70) {
        return 70;
      } else if (stuff === 71) {
        return 71;
      } else if (stuff === 72) {
        return 72;
      } else if (stuff === 73) {
        return 73;
      } else if (stuff === 74) {
        return 74;
      } else if (stuff === 75) {
        return 75;
      } else if (stuff === 76) {
        return 76;
      } else if (stuff === 77) {
        return 77;
      } else if (stuff === 78) {
        return 78;
      } else if (stuff === 79) {
        return 79;
      } else if (stuff === 80) {
        return 80;
      } else if (stuff === 81) {
        return 81;
      } else if (stuff === 82) {
        return 82;
      } else if (stuff === 83) {
        return 83;
      } else if (stuff === 84) {
        return 84;
      } else if (stuff === 85) {
        return 85;
      } else if (stuff === 86) {
        return 86;
      } else if (stuff === 87) {
        return 87;
      } else if (stuff === 88) {
        return 88;
      } else if (stuff === 89) {
        return 89;
      } else if (stuff === 90) {
        return 90;
      } else if (stuff === 91) {
        return 91;
      } else if (stuff === 92) {
        return 92;
      } else if (stuff === 93) {
        return 93;
      } else if (stuff === 94) {
        return 94;
      } else if (stuff === 95) {
        return 95;
      } else if (stuff === 96) {
        return 96;
      } else if (stuff === 97) {
        return 97;
      } else if (stuff === 98) {
        return 98;
      } else if (stuff === 99) {
        return 99;
      } else
    }
    
    function switchTest(stuff) {
      switch (stuff) {
    
        case 0:
          return 0;
        case 1:
          return 1;
        case 2:
          return 2;
        case 3:
          return 3;
        case 4:
          return 4;
        case 5:
          return 5;
        case 6:
          return 6;
        case 7:
          return 7;
        case 8:
          return 8;
        case 9:
          return 9;
        case 10:
          return 10;
        case 11:
          return 11;
        case 12:
          return 12;
        case 13:
          return 13;
        case 14:
          return 14;
        case 15:
          return 15;
        case 16:
          return 16;
        case 17:
          return 17;
        case 18:
          return 18;
        case 19:
          return 19;
        case 20:
          return 20;
        case 21:
          return 21;
        case 22:
          return 22;
        case 23:
          return 23;
        case 24:
          return 24;
        case 25:
          return 25;
        case 26:
          return 26;
        case 27:
          return 27;
        case 28:
          return 28;
        case 29:
          return 29;
        case 30:
          return 30;
        case 31:
          return 31;
        case 32:
          return 32;
        case 33:
          return 33;
        case 34:
          return 34;
        case 35:
          return 35;
        case 36:
          return 36;
        case 37:
          return 37;
        case 38:
          return 38;
        case 39:
          return 39;
        case 40:
          return 40;
        case 41:
          return 41;
        case 42:
          return 42;
        case 43:
          return 43;
        case 44:
          return 44;
        case 45:
          return 45;
        case 46:
          return 46;
        case 47:
          return 47;
        case 48:
          return 48;
        case 49:
          return 49;
        case 50:
          return 50;
        case 51:
          return 51;
        case 52:
          return 52;
        case 53:
          return 53;
        case 54:
          return 54;
        case 55:
          return 55;
        case 56:
          return 56;
        case 57:
          return 57;
        case 58:
          return 58;
        case 59:
          return 59;
        case 60:
          return 60;
        case 61:
          return 61;
        case 62:
          return 62;
        case 63:
          return 63;
        case 64:
          return 64;
        case 65:
          return 65;
        case 66:
          return 66;
        case 67:
          return 67;
        case 68:
          return 68;
        case 69:
          return 69;
        case 70:
          return 70;
        case 71:
          return 71;
        case 72:
          return 72;
        case 73:
          return 73;
        case 74:
          return 74;
        case 75:
          return 75;
        case 76:
          return 76;
        case 77:
          return 77;
        case 78:
          return 78;
        case 79:
          return 79;
        case 80:
          return 80;
        case 81:
          return 81;
        case 82:
          return 82;
        case 83:
          return 83;
        case 84:
          return 84;
        case 85:
          return 85;
        case 86:
          return 86;
        case 87:
          return 87;
        case 88:
          return 88;
        case 89:
          return 89;
        case 90:
          return 90;
        case 91:
          return 91;
        case 92:
          return 92;
        case 93:
          return 93;
        case 94:
          return 94;
        case 95:
          return 95;
        case 96:
          return 96;
        case 97:
          return 97;
        case 98:
          return 98;
        case 99:
          return 99;
    
      }
    };
    
    var lookupTable = [
    
      function() 0,
      function() 1,
      function() 2,
      function() 3,
      function() 4,
      function() 5,
      function() 6,
      function() 7,
      function() 8,
      function() 9,
      function() 10,
      function() 11,
      function() 12,
      function() 13,
      function() 14,
      function() 15,
      function() 16,
      function() 17,
      function() 18,
      function() 19,
      function() 20,
      function() 21,
      function() 22,
      function() 23,
      function() 24,
      function() 25,
      function() 26,
      function() 27,
      function() 28,
      function() 29,
      function() 30,
      function() 31,
      function() 32,
      function() 33,
      function() 34,
      function() 35,
      function() 36,
      function() 37,
      function() 38,
      function() 39,
      function() 40,
      function() 41,
      function() 42,
      function() 43,
      function() 44,
      function() 45,
      function() 46,
      function() 47,
      function() 48,
      function() 49,
      function() 50,
      function() 51,
      function() 52,
      function() 53,
      function() 54,
      function() 55,
      function() 56,
      function() 57,
      function() 58,
      function() 59,
      function() 60,
      function() 61,
      function() 62,
      function() 63,
      function() 64,
      function() 65,
      function() 66,
      function() 67,
      function() 68,
      function() 69,
      function() 70,
      function() 71,
      function() 72,
      function() 73,
      function() 74,
      function() 75,
      function() 76,
      function() 77,
      function() 78,
      function() 79,
      function() 80,
      function() 81,
      function() 82,
      function() 83,
      function() 84,
      function() 85,
      function() 86,
      function() 87,
      function() 88,
      function() 89,
      function() 90,
      function() 91,
      function() 92,
      function() 93,
      function() 94,
      function() 95,
      function() 96,
      function() 97,
      function() 98,
      function() 99,
    ];

Test runner

Ready to run.

Testing in
TestOps/sec
if else
ifElseTest(0);
ifElseTest(1);
ifElseTest(2);
ifElseTest(3);
ifElseTest(4);
ifElseTest(5);
ifElseTest(6);
ifElseTest(7);
ifElseTest(8);
ifElseTest(9);
ifElseTest(10);
ifElseTest(11);
ifElseTest(12);
ifElseTest(13);
ifElseTest(14);
ifElseTest(15);
ifElseTest(16);
ifElseTest(17);
ifElseTest(18);
ifElseTest(19);
ifElseTest(20);
ifElseTest(21);
ifElseTest(22);
ifElseTest(23);
ifElseTest(24);
ifElseTest(25);
ifElseTest(26);
ifElseTest(27);
ifElseTest(28);
ifElseTest(29);
ifElseTest(30);
ifElseTest(31);
ifElseTest(32);
ifElseTest(33);
ifElseTest(34);
ifElseTest(35);
ifElseTest(36);
ifElseTest(37);
ifElseTest(38);
ifElseTest(39);
ifElseTest(40);
ifElseTest(41);
ifElseTest(42);
ifElseTest(43);
ifElseTest(44);
ifElseTest(45);
ifElseTest(46);
ifElseTest(47);
ifElseTest(48);
ifElseTest(49);
ifElseTest(50);
ifElseTest(51);
ifElseTest(52);
ifElseTest(53);
ifElseTest(54);
ifElseTest(55);
ifElseTest(56);
ifElseTest(57);
ifElseTest(58);
ifElseTest(59);
ifElseTest(60);
ifElseTest(61);
ifElseTest(62);
ifElseTest(63);
ifElseTest(64);
ifElseTest(65);
ifElseTest(66);
ifElseTest(67);
ifElseTest(68);
ifElseTest(69);
ifElseTest(70);
ifElseTest(71);
ifElseTest(72);
ifElseTest(73);
ifElseTest(74);
ifElseTest(75);
ifElseTest(76);
ifElseTest(77);
ifElseTest(78);
ifElseTest(79);
ifElseTest(80);
ifElseTest(81);
ifElseTest(82);
ifElseTest(83);
ifElseTest(84);
ifElseTest(85);
ifElseTest(86);
ifElseTest(87);
ifElseTest(88);
ifElseTest(89);
ifElseTest(90);
ifElseTest(91);
ifElseTest(92);
ifElseTest(93);
ifElseTest(94);
ifElseTest(95);
ifElseTest(96);
ifElseTest(97);
ifElseTest(98);
ifElseTest(99);
ready
switch
switchTest(0);
switchTest(1);
switchTest(2);
switchTest(3);
switchTest(4);
switchTest(5);
switchTest(6);
switchTest(7);
switchTest(8);
switchTest(9);
switchTest(10);
switchTest(11);
switchTest(12);
switchTest(13);
switchTest(14);
switchTest(15);
switchTest(16);
switchTest(17);
switchTest(18);
switchTest(19);
switchTest(20);
switchTest(21);
switchTest(22);
switchTest(23);
switchTest(24);
switchTest(25);
switchTest(26);
switchTest(27);
switchTest(28);
switchTest(29);
switchTest(30);
switchTest(31);
switchTest(32);
switchTest(33);
switchTest(34);
switchTest(35);
switchTest(36);
switchTest(37);
switchTest(38);
switchTest(39);
switchTest(40);
switchTest(41);
switchTest(42);
switchTest(43);
switchTest(44);
switchTest(45);
switchTest(46);
switchTest(47);
switchTest(48);
switchTest(49);
switchTest(50);
switchTest(51);
switchTest(52);
switchTest(53);
switchTest(54);
switchTest(55);
switchTest(56);
switchTest(57);
switchTest(58);
switchTest(59);
switchTest(60);
switchTest(61);
switchTest(62);
switchTest(63);
switchTest(64);
switchTest(65);
switchTest(66);
switchTest(67);
switchTest(68);
switchTest(69);
switchTest(70);
switchTest(71);
switchTest(72);
switchTest(73);
switchTest(74);
switchTest(75);
switchTest(76);
switchTest(77);
switchTest(78);
switchTest(79);
switchTest(80);
switchTest(81);
switchTest(82);
switchTest(83);
switchTest(84);
switchTest(85);
switchTest(86);
switchTest(87);
switchTest(88);
switchTest(89);
switchTest(90);
switchTest(91);
switchTest(92);
switchTest(93);
switchTest(94);
switchTest(95);
switchTest(96);
switchTest(97);
switchTest(98);
switchTest(99);
ready
lookup table
lookupTable[0]();
lookupTable[1]();
lookupTable[2]();
lookupTable[3]();
lookupTable[4]();
lookupTable[5]();
lookupTable[6]();
lookupTable[7]();
lookupTable[8]();
lookupTable[9]();
lookupTable[10]();
lookupTable[11]();
lookupTable[12]();
lookupTable[13]();
lookupTable[14]();
lookupTable[15]();
lookupTable[16]();
lookupTable[17]();
lookupTable[18]();
lookupTable[19]();
lookupTable[20]();
lookupTable[21]();
lookupTable[22]();
lookupTable[23]();
lookupTable[24]();
lookupTable[25]();
lookupTable[26]();
lookupTable[27]();
lookupTable[28]();
lookupTable[29]();
lookupTable[30]();
lookupTable[31]();
lookupTable[32]();
lookupTable[33]();
lookupTable[34]();
lookupTable[35]();
lookupTable[36]();
lookupTable[37]();
lookupTable[38]();
lookupTable[39]();
lookupTable[40]();
lookupTable[41]();
lookupTable[42]();
lookupTable[43]();
lookupTable[44]();
lookupTable[45]();
lookupTable[46]();
lookupTable[47]();
lookupTable[48]();
lookupTable[49]();
lookupTable[50]();
lookupTable[51]();
lookupTable[52]();
lookupTable[53]();
lookupTable[54]();
lookupTable[55]();
lookupTable[56]();
lookupTable[57]();
lookupTable[58]();
lookupTable[59]();
lookupTable[60]();
lookupTable[61]();
lookupTable[62]();
lookupTable[63]();
lookupTable[64]();
lookupTable[65]();
lookupTable[66]();
lookupTable[67]();
lookupTable[68]();
lookupTable[69]();
lookupTable[70]();
lookupTable[71]();
lookupTable[72]();
lookupTable[73]();
lookupTable[74]();
lookupTable[75]();
lookupTable[76]();
lookupTable[77]();
lookupTable[78]();
lookupTable[79]();
lookupTable[80]();
lookupTable[81]();
lookupTable[82]();
lookupTable[83]();
lookupTable[84]();
lookupTable[85]();
lookupTable[86]();
lookupTable[87]();
lookupTable[88]();
lookupTable[89]();
lookupTable[90]();
lookupTable[91]();
lookupTable[92]();
lookupTable[93]();
lookupTable[94]();
lookupTable[95]();
lookupTable[96]();
lookupTable[97]();
lookupTable[98]();
lookupTable[99]();
ready

Revisions

You can edit these tests or add more tests to this page by appending /edit to the URL.