programme de design pour éviter un grand if-else bloc

Question

J'ai une grande liste des masques et des codes

var codes = [ 
    foo: { mask: 0x1234, code: 0x0010 }, 
    bar: { mask: 0x1F00, code: 0x0310 }, 
    bla: { mask: 0x12F0, code: 0x2010 } 
    ... 
] 

Et je veux effectuer certaines opérations ...

var doStuff = function(number) { 

    if ((number & codes.foo.mask) == codes.foo.code) { 
    // do some stuff 

    } else if ((number & codes.bar.mask) == codes.bar.code) { 
    // do other stuff 

    } else if ((number & codes.bla.mask) == codes.bla.code) { 
    // do other stuff 
    } 
    ... 

} 

Comment décririez-vous la conception votre programme pour éviter le grand bloc if-else? L'exemple de code est en javascript, mais un motif de conception dans n'importe quelle langue est ok pour moi.

Answer 1

Vous pouvez ajouter les //do some stuff parties dans le foo, bar BLA objets, puis boucle un peu plus le tableau-à-dire

var codes = { 
    foo: { mask: 0x1234, code: 0x0010, action: function(){/*do foo stuff*/} }, 
    bar: { mask: 0x1F00, code: 0x0310, action: function(){/*do bar stuff*/} }, 
    bla: { mask: 0x12F0, code: 0x2010, action: function(){/*do bla stuff*/} } 
    ... 
} 

for (var item in codes){ 
    if ((number & codes[item].mask) == codes[item].code) 
    codes[item].action(); 
} 

Vous pouvez également créer un tableau associatif séparé uniquement pour la fonction, si vous ne souhaitez pas mélanger les données avec le code (c'est-à-dire si les codes sont extraits d'un serveur)

var codes = { 
    foo: { mask: 0x1234, code: 0x0010}, 
    bar: { mask: 0x1F00, code: 0x0310}, 
    bla: { mask: 0x12F0, code: 0x2010} 
    ... 
} 

var funcs = { 
    foo : function {/* do foo stuff */ }, 
    bar : function {/* do bar stuff */ }, 
    bla : function {/* do bla stuff */ }, 
} 

for (var item in codes){ 
    if ((number & codes[item].mask) == codes[item].code) 
    funcs[item](); 
} 

Answer 2

Peut créer un tableau avec le nom des fonctions dans chaque cas où le code est l'index et nommez la valeur.

array[code] = "function_name" 

ensuite appliqué le masque et appeler la fonction:

call(array[number & codes.foo.mask]) 

Answer 3

Très simplement, j'utiliserais un motif Strategy. Les gens dans votre situation ont longtemps traité ce problème avec une usine et un polymorphisme, qui était la base de la stratégie.