notCondition2And3 = !condition2 & !condition3;
// in place of notCondition2And3 should be some meaningful name
// representing what it actually MEANS that neither condition2 nor condition3 were true
E ora:
if (condition1 || notCondition2And3)
{
Statement1A;
Statement1B;
return;
}
if (condition2)
{
Statement2;
return;
}
if (condition3)
{
Statement3;
return;
}
Come ho scritto nel mio commento alla risposta di Kieveli , non vedo nulla di sbagliato in più return s in un metodo, se non ci sono considerazioni sulla gestione della memoria (come potrebbe essere il caso in C o C ++ in cui è necessario rilasciare tutte le risorse manualmente prima di partire).
O ancora un altro approccio. Ecco la matrice delle decisioni in modo da non rovinarlo:
F F F - 1
---------
F F T - 3
---------
F T F - 2
F T T - 2
---------
T F F - 1
T F T - 1
T T F - 1
T T T - 1
T s e F s rappresentano i valori di condition1 , condition2 e condition3 (rispettivamente). I numeri rappresentano i risultati.
Rende chiaro che è anche possibile scrivere il codice come:
if (!condition1 && condition2) // outcome 2 only possible for FTF or FTT, condition3 irrelevant
{
Statement2;
return;
}
if (!condition1 && !condition2 && condition3) // outcome 3 only when FFT
{
Statement3;
return;
}
// and for the remaining 5 combinations...
Statement1A;
Statement1B;
Ora se abbiamo estratto !condition1 (che è presente in ifs ), avremmo:
if (!condition1)
{
if (condition2) // outcome 2 only possible for FTF or FTT, condition3 irrelevant
{
Statement2;
return;
}
if (condition3) // outcome 3 only when FFT
{
Statement3;
return;
}
}
// and for the remaining 5 combinations...
Statement1A;
Statement1B;
Che è quasi esattamente quello che ha suggerito Kieveli, solo il suo disprezzo per l'iniziale return s ha causato la sua implementazione di errori (come ha notato lui stesso), perché non avrebbe fatto nulla se tutte e tre le condizioni fossero false.
Oppure potremmo ripristinarlo in questo modo (questo probabilmente non funzionerebbe in tutte le lingue - funziona in C #, per esempio, dato che C # consente il confronto dell'uguaglianza tra più variabili), ora siamo praticamente tornati al primo uno:
// note that "condition1" on the right side of || is actually redundant and can be removed,
// because if the expression on the right side of || gets evaluated at all,
// it means that condition1 must have been false anyway:
if (condition1 || (condition1 == condition2 == condition3 == false)) // takes care of all 4 x T** plus FFF (the one special case).
{
Statement1A;
Statement1B;
return;
}
// and now it's nice and clean
if (condition2)
{
Statement2;
return; // or "else" if you prefer
}
if (condition3)
{
Statement3;
return; // if necessary
}