Instruction de commutateur récursive

Question

Je reçois une valeur undefined pour une instruction de commutation récursive lorsque le mode est aléatoire. L'idée est que c'est le plus id aléatoire, il serait aléatoire de sélectionner un nombre et de définir un nouveau mode et retourner l'instruction de commutateur d'origine.

Everthing fonctionne correctement lorsque le mode n'est pas aléatoire. Donc, je ne suis pas sûr de ce qui ne va pas ici.
la variable a est le mode, alors que i,j sont simplement des nombres.

switchMode: function (i, j, a){ 
      var b; 
      console.log(a); 
      switch(a) { 
       default: 
       case 'add': 
        console.log(i, j); 
        b = i + j; 
        break; 

       case 'minus': 
        console.log(i, j); 
        b = i - j; //negative numbers possible 
        break; 

       case 'multiply': 
        console.log(i, j); 
        b = i * j; //0 possible 
        break; 

       case 'random': 
        this.randomSwitchMode(i, j); 
        break; //random 
      } 
      return b; 
     }, 



randomSwitchMode: function(i, j) { 
      var c = Math.ceil(Math.random() * 3); 

      console.log(i, j, c); 

      switch(c) { 
       default: 
       case 1: 
        var a = 'add'; 
        console.log(a); 
        this.switchMode(i, j, a); 
        break; 

       case 2: 
        var a = 'minus'; 
        console.log(a); 
        this.switchMode(i, j, a); 
        break; 

       case 3: 
        var a = 'multiply'; 
        console.log(a); 
        this.switchMode(i, j, a); 
        break; 
      } 
     } 

Answer 1

Vous ne renvoyez rien de "randomSwitchMode". Même si vous faites cela, vous devrez également vous assurer que vous affectez sa valeur de retour à "b" dans "switchMode".

Ainsi, les cas aléatoires devraient ressembler à:

  case 1: 
       var a = 'add'; 
       console.log(a); 
       return this.switchMode(i, j, a); 

puis dans « SWITCHMODE »:

  case 'random': 
       b = this.randomSwitchMode(i, j); 
       break; //random 

Puisque vous allez tout ce mal de toute façon, je vous offre la suggestion qu'au lieu d'utiliser une instruction switch vous conservez un objet qui mappe les noms d'opération à des fonctions:

switchMode: function (i, j, a) { 
    var ops = { 
    'add': function(i, j) { return i + j; }, 
    'minus': function(i, j) { return i - j; }, 
    'multiply': function(i, j) { return i * j; }, 
    'random': function(i, j) { 
     return ops[['add', 'minus', 'multiply'][Math.floor(Math.random() * 3)]](i, j); 
    } 
    }; 
    return ops[a](i, j); 
} 

Vous pourriez séparer le cas "aléatoire" et le gérer différemment, je suppose. Le point d'ensemble est que, bien qu'il n'y ait rien de fondamentalement faux avec une instruction switch, baser l'implémentation sur une structure de données va être plus flexible.