Che è più costoso in termini di costi di elaborazione
if ( x < 20 && z == "M") {
// statements 3
}
if ( x >= 20 && w && x <= 65) {
// statements 1
}
if( x >= 20 && z == "F"){
// statements 2
}
o questo
if ( x < 20 ) {
if( z == 'M') // statements 3;
} else
if ( x <= 65 && w == true ) // statements 1;
if ( z == 'F' ) // statements 2;
}
Eseguili il profilo
.... poi vedrai quale è il più costoso.
In tutta serietà, la risposta che stai cercando dipende da molti, molti fattori come il linguaggio (il tuo esempio potrebbe essere qualsiasi se parecchie lingue), il compilatore, le impostazioni del compilatore, l'uso della piattaforma e del runtime.
Se si chiama questo codice solo una volta, le prestazioni sono irrilevanti rispetto alla manutenibilità: la versione facile da gestire.
In termini di leggibilità, si desidera mantenere le condizioni nelle istruzioni if..else sia mutuamente esclusive che collettivamente esaurienti . In altre parole, ogni test dovrebbe corrispondere a 1 e solo a 1 condizione.
Se disponi di condizioni non correlate (ad esempio, "numero di membri" e "redditività"), non vuoi contaminarle con && inserendole insieme. Pertanto, nella maggior parte dei casi, è meglio avere nidificati blocchi if..else .
if (members <= 100) {
if (nonProfit) {
// ...
} else if (notForProfit) {
// ...
} else {
// ...
}
} else if (100 < members && members <= 1000) {
if (profitable) {
// ...
} else {
// ...
}
} else {
// ...
}
Con strutture condizionali più rigide (ad es., ripetendo blocchi if..else ), probabilmente stai meglio usando ricerche oggetto . Non solo le ricerche di oggetti sono più veloci, ma sono molto più leggibili e più facili da capire a mio parere. Sono meno flessibili di if..else , che può essere vantaggioso o svantaggioso in base alle tue esigenze.
Quello che stai facendo è chiamato "micro-ottimizzazione", ma sarebbe meglio chiamarlo "nano-ottimizzazione". Non vale assolutamente nemmeno la pena di tentare. Se vuoi rendere il codice più veloce, è un problema che deve essere attaccato a un livello molto più alto.
A quel livello, rendi il tuo codice il più leggibile possibile. Rendilo il più possibile manutenibile. Qualsiasi cosa per ridurre il tempo necessario a produrre codice funzionante correttamente. Ora puoi usare il tempo risparmiato per fare alcune ottimizzazioni reali (se è importante per gli utenti, molto probabilmente saranno più felici con più funzioni). E avendo un codice leggibile e manutenibile, è più facile o addirittura possibile fare ottimizzazioni reali che consentono di risparmiare tempo misurabile.
E diciamo solo che le tue due versioni del codice non sono equivalenti. Uno, non sono equivalenti perché hai fatto degli errori. Questo è un problema con questo tipo di ottimizzazione; se non si è abbastanza concentrati per evitare errori stupidi, i tentativi di ottimizzazione portano al fallimento. E l'altro problema è che "dichiarazioni 3" potrebbero cambiare il valore di x, nel qual caso c'è un'enorme differenza tra i due codici.
Supponendo che lo stai facendo in C o C ++ e assumendo un compilatore di qualità di produzione:
Se x è stato dichiarato "volatile", il primo sarà leggermente più costoso e il secondo potrebbe produrre risultati errati.
Se x non è stato dichiarato "volatile" e l'ottimizzazione è attiva, dovrebbero fornire un codice identico.
Leggi altre domande sui tag performance optimization