Modo elegante per gestire più percorsi in base alle condizioni del composto [chiuso]

Question

Modo elegante per gestire più percorsi in base alle condizioni del composto [chiuso]

#1 da (8 voti)
#2 da (4 voti)
#3 da (3 voti)
#4 da (1 voti)

4

Considera quanto segue:

if (x == 5 || x == 10 || x == 12) {
    if (x == 5) {
        doSomething()
    } else if (x == 10) {
        doSomethingElse()
    } else {
        doSomeOtherThing()
    }

    doMoreThings()
}

doThingsAfterThat()

Il secondo insieme di condizioni si sente ripetitivo, come le ho specificato nella condizione originale. Potrei separarlo in due condizionali, ma poi ripeterei 'doSomeOtherThings ()'.

Qual è il modo più elegante per gestirlo?

Modifica :

Questo non è un duplicato di modi eleganti per gestire if (if altro) . Le ragioni sono:

Nella potenziale domanda duplicata, la condizione interna sta testando un valore diverso di quello che viene testato nella condizione originale. In questa domanda, le condizioni interne testate sono le stesse della condizione originale.
In questa domanda, si deve prendere in considerazione più se, altrimenti se le affermazioni. La potenziale domanda duplicata non lo considera.

coding-style conditions dry

posta David Poxon 18.09.2015 - 06:15

fonte

4 risposte

Leggi altre domande sui tag coding-style conditions dry

È inopportuno archiviare i dati come json in testo normale? [duplicare] Notazioni ungheresi / Sistemi Ungherese dovrei? [chiuso]

score 8 · Answer 1

Esistono procedure (o funzioni o metodi) a causa della necessità di applicare lo stesso modello di azioni in molte situazioni. Quindi non c'è niente di sbagliato nel ripetere una chiamata al metodo alcune volte. La ripetizione di una chiamata tre volte non è un problema.

Quindi mantienilo semplice, evita l'annidamento inutile, minimizza le linee di codice e minimizza i passaggi eseguiti.

if (x == 5) {
    doSomething();
    doMoreThings();
} else if (x == 10) {
    doSomethingElse();
    doMoreThings();
} else if (x == 12) {
    doSomeOtherThing();
    doMoreThings();
}
doThingsAfterThat();

score 4 · Answer 2

La soluzione migliore è quella che riduce al minimo la quantità di codice che è necessario scrivere, e quindi la quantità di codice che è necessario per leggere per capire cosa sta succedendo. Generalmente leggiamo ogni dato pezzo di codice molto più volte di quanto lo scriviamo, quindi la chiarezza è la qualità più importante del codice. (Oltre alla correttezza, ovviamente.)

Alla luce di ciò, il codice nella tua stessa domanda è l'opzione migliore.

Anche la risposta di "Come from" è abbastanza buona, ma in fondo è più naturale pensare alla soluzione del problema che il tuo codice sta risolvendo. Presumibilmente hai scritto il tuo codice a modo tuo e non "vieni da" perché questo era il modo più naturale per pensare a risolvere il tuo problema. Quindi, questo è (quasi per definizione direi) il modo migliore.

Qualsiasi altra opzione ulteriormente complicherà il tuo codice, e per cosa? al fine di evitare scrivere un paio di ulteriori dichiarazioni, siano esse dichiarazioni if o istruzioni di chiamata di funzione.

Si noti che il fatto che si scrivano queste istruzioni due volte non necessariamente significa che saranno emesse dal compilatore due volte, o eseguite due volte: certi che il compilatore farà del suo meglio per ristrutturare il codice emesso in modo da evitare inutili duplicazioni. (E se non può, allora ci sarà un piccolo bit di duplicazione. E allora?)

Essenzialmente, dato che il compilatore è libero di fare tutto ciò che è dietro le quinte, l'unico scopo rimanente del codice è spiegare cosa deve accadere nel modo più chiaro possibile. La concisione è anche un obiettivo nobile, ma mai a scapito della chiarezza.

score 3 · Answer 3

È potrebbe aiutare se dai un nome alle condizioni ma penso che sia discutibile in questo semplice esempio. Con condizioni più complesse, il vantaggio sarebbe più chiaro. Se un giorno decidi di cambiare una condizione, dovrai farlo solo in un posto e non rischiare di introdurre un'incoerenza.

final boolean someP = (x == 5);
final boolean elseP = (x == 10);
final boolean otherP = (x == 12);

if (someP) {
    doSomething();
}
if (elseP) {
    doSomethingElse();
}
if (otherP) {
    doSomeOtherThing();
}
if (someP || elseP || otherP) {
    doMoreThings();
}

doThingsAfterThat();

score 1 · Answer 4

Perché non usare case per singoli se e uno se per o condizione.

switch (x) {
 case 5: doSomething5();
        break;
   case 10: doSomething10();
        break;
case 12 : doSomething12();
        break;
}

if (x==5 || x == 10 || x == 12){
doMoreThings();
}
doThingsAfterThat();

doMoreThings può essere anche all'interno del case. Ma sarà ripetitivo.

switch (x){

case 5: doSomething5();
         doMoreThings();
        break;
case 10: doSomething10();
         doMoreThings();
        break;
case 12 : doSomething12();
         doMoreThings();
       break;
       }

* se le condizioni sono complesse allora semplice controllo delle variabili, questo non funzionerà.