Meilleure alternative pour plusieurs instructions de commutateur imbriquées?

Ayez une carte de toutes les variations possibles et ses valeurs:

// Key is composite of `"" + var1 + "_" + var2 + "_" + i` and trimmed `_` from back

let tree = {
    '1_0_test_0': '123',
    '1_0_test_2': '124',
    '1_0_test': '125',
    '1_0_1': '126',
    ...
}

let key = ("" + var1 + var2 + i).replace(/_{2,}|_+$/, '');

if (typeof tree[key] !== 'undefined') {
    endresult.push({id: i, content: tree[key]});
}

Votre préoccupation est la lisibilité, n'est-ce pas? Vous devez probablement diviser un peu votre code. Et utilisez des noms de variables au lieu de 0 et 1. Vous devez également fournir plus de détails. Comme peut-il aller au-delà de 0 et 1 à 2 et 3, etc. Je ne sais pas comment vous appelez votre code.

Cependant, vous pouvez essayer (un mélange d'objets et if-else):

const decideFn = ({ var1, var2, var3, i }) = {
    const decision = {
        1: {
            0: {
                cond(i) {
                    if (var3 === 'test') {
                        if (i === 0) 
                            endresult.push({id: i, content: '123'})
                        else if (i === 2) 
                            endresult.push({id: i, content: '124'})
                        else 
                            endresult.push({id: i, content: '125'})
                    }
                    else endresult.push({id: i, content: '125'})
                }
            },
            1: {
                cond(i) { 
                   endresult.push({id: i, content: '126'}) 
                }
            }
        }
        2: {
            0: {
                cond(i) {            
                    if (i === 0) 
                        endresult.push({id: i, content: '127'})
                    else if (i === 2) 
                        endresult.push({id: i, content: '128'})}
                },
            1: {
                cond(i) {
                    if (i === 0) 
                        endresult.push({id: i, content: '128'})
                    else if (i === 2) 
                        endresult.push({id: i, content: '129'}) 
                }
            }
        }
    }

    // usage
    // does i go in a loop ?
    // your qn needs more details. but i hope you get the idea
    decision[var1][var2].cond(i)

}

En fin de compte, cela se résume vraiment à la façon dont vous pensez comprendre le mieux le code et comment les autres développeurs liront votre code mais personnellement, je pense que vos instructions de commutation sont correctes.

Les objets peuvent cependant donner plus de flexibilité.

Si dans tous les cas vous poussez vers la même variable, j'envisagerais de créer une fonction dont le seul travail est de déterminer la bonne valeur en fonction des variables.

Cela pourrait ressembler à ceci:

const getContentValue(var1, var2, var3, i) {
 if (var1 === 1) {
   if (var2 === 0) {
     if (var3 === 'test') {
       if (i === 0) return '123'
       if (i === 2) return '124'
       return '125'
   }
   if (var2 === 1) {
     return '126'
   }
 }
 if (var1 === 2) {
   if (var2 === 0) {
     if (i === 0) return '127'
     if (i === 2) return '128'
   }
   if (var2 === 1) {
     if (i === 0) return '128'
     if (i === 2) return '129'
   }
 }
}

endResult.push({ id: i, content: getContentValue(var1, var2, var3, i) })

(Le code n'a pas été testé.)

Quelques points à noter et quelques principes à retenir:

• La "structure de décision" de base est la même, mais simplifiée en utilisant une instruction if . Le passage d'un cas à l'autre est, à mon avis, quelque chose que l'on fait quand on a beaucoup de cas, pas quand on bascule entre deux choses. Les instructions if fonctionnent très bien lorsque vous basculez entre deux options. Si vous travaillez vraiment avec un tas de cas, disons que votre var1 pourrait en fait être plus de 10 nombres différents, il pourrait être plus simple de s'en tenir à un commutateur .
• Si vous regardez l'instruction switch dans votre code, il y en a beaucoup qui sont identiques dans tous les cas. Une astuce consiste à regarder les changements dans la réponse pour chaque cas. i est le même. Seuls les chiffres changent. C'est une bonne voie à suivre pour simplifier les choses.
• Je ne pense pas que ce soit intentionnel, mais vous avez deux cas qui aboutissent au nombre 128. Vous pouvez probablement faire une simplification supplémentaire. (Difficile à savoir exactement parce que je sais que les exemples de données que vous avez ne sont pas exactement les données réelles avec lesquelles vous travaillez.) Je commente parce que c'est en fait un bon moment d'enseignement - si vous avez des cas finaux identiques, c'est quelque chose à prendre un bon aperçu.
• Notez les similitudes entre les concepts d'une instruction switch et d'une instruction if . Dans une fonction, si vous avez une instruction return, elle agira comme le break d'une instruction switch . Si vous revenez après chaque cas if , vous aurez l'équivalent d'un cas default lorsque vous aurez suffisamment d'informations pour savoir quoi renvoyer. (Par exemple, voyez la ligne qui dit return '125' . Nous savons que si nous arrivons à ce point, 125 devrait être renvoyé.)