Więc mam oświadczenie z wieloma przypadkami, np.

switch(var){
    case 1:
        myfunc();
    break;
    ...
    case 40:
        myanotherfunc();
    break;
}

Czy oddziela te przypadki w kilku pod-przełączy dobry sposób na poprawę wydajności? Na przykład.

    switch(var){
        case 1:
            switch(var2){
                 case 1:
                      myfunc();
                 break;

                 case 2:
                      myfuncfoo();
                 break;
             };
        break;
        ...
        case 5:
            switch(var2){
                 case 1:
                      myfunct();
                 break;

                 case 2:
                      myfuncfoobar();
                 break;
            };
         break;

Myślę, że w tym przypadku JS nie sprawdzi wszystkich przypadków, sprawdzi najpierw kilka przypadków, a następnie drugi kilka przypadków itp.

0
SLy_huh 12 sierpień 2014, 12:31

2 odpowiedzi

Najlepsza odpowiedź

Intrygowany postanowiłem stworzyć bardzo szybki test. Wygląda na to, że jest bardzo mała różnica - mądry, jeśli sprawa jest losowa.

Być może znaczące różnice są widoczne, ponieważ przełącznik jest znacznie większy, ale powiedziałbym średnio, nadal byłoby to skłonić do szczęścia (które przypadki są trafione, wcześniej jeden lub późniejszy), który jest szybszy.

function bigSwitch(value){
    switch(value){
        case 1:
            break;
        case 2:
            break;
        case 3:
            break;
        case 4:
            break;
        case 5:
            break;
        case 6:
            break;
        case 7:
            break;
        case 8:
            break;
        case 9:
            break;
        case 10:
            break;
        case 11:
            break;
        case 12:
            break;
        case 13:
            break;
        case 14:
            break;
        case 15:
            break;
        case 16:
            break;
        case 17:
            break;
        case 18:
            break;
        case 19:
            break;
        case 20:
            break;    
    }
}

function smallSwitch(value){    
    switch(Math.floor(value/5)+1){
        case 1:
            switch(value%5){
                case 1:
                    break;
                case 2:
                    break;
                case 3:
                    break;
                case 4:
                    break;
                case 5:
                    break;
            }
            break;
        case 2:
            switch(value%5){
                case 1:
                    break;
                case 2:
                    break;
                case 3:
                    break;
                case 4:
                    break;
                case 5:
                    break;
            }
            break;
        case 3:
            switch(value%5){
                case 1:
                    break;
                case 2:
                    break;
                case 3:
                    break;
                case 4:
                    break;
                case 5:
                    break;
            }
            break;
        case 4:
            switch(value%5){
                case 1:
                    break;
                case 2:
                    break;
                case 3:
                    break;
                case 4:
                    break;
                case 5:
                    break;
            }
            break;
    }
}

var runsToDo = 10000000;
var timer = Date.now();
for(var i=0; i<runsToDo; i++){
    var value = Math.floor(Math.random()*20) + 1; 
    bigSwitch(value);     
}
console.log("BigSwitch time = ", Date.now() - timer); 

timer = Date.now();
for(var i=0; i<runsToDo; i++){
    var value = Math.floor(Math.random()*20) + 1; 
    smallSwitch(value); 
}
console.log("smallSwitch time = ", Date.now() - timer);

Zobacz: http://jsfiddle.net/m67uhuxy/

0
James 12 sierpień 2014, 09:16

Nie wiem o wydajności - to jest funkcja, która zmienia się od silnika JavaScript do silnika JavaScript, ale czytelność mądra, jest okropny.

Ponieważ JavaScript ma taką doskonałą obsługę klucza / wartości w obiektach, a dostęp do obiektu Zoptymalizowany, aby być nierozsądnie szybkim, znalazłem się nigdy więcej nie korzystając z instrukcji przełącznika.

var myDoGizmo = {
  "1": {
     "1": func1_1,
     "2": func1_2
   },
  "2": {
     "1": func2_1,
     "2": func2_2
   }
};

// Maybe a guard here if there can possibly be an out-of-range value.    
myDoGizmo[1][1]();
0
Jeremy J Starcher 12 sierpień 2014, 08:36