Metodo di refactoring con cicli nidificati e 6 variabili [duplicato]

Senza vedere il codice, o informazioni su quale linguaggio è implementato nel suo difficile per fornire una soluzione specifica per il problema. Dici metodo in modo che possa escludere alcune soluzioni che potrebbero essere applicabili in alcune lingue.

Dal modo in cui si pone la soluzione, sembra che la velocità sia essenziale ma si è costretti a incorrere in qualche overhead decomprimendo il ciclo, sebbene (se si utilizza un linguaggio compilato) possa inline alcune cose per voi.

Se stai usando C, C ++ o un'altra lingua che ha dei puntatori, prenderei in considerazione la possibilità di scomporre i loop in funzioni appropriatamente chiamate e passare lungo quelle variabili richieste dal ciclo.

Inoltre, a seconda di come il tuo calcolo è disposto in memoria, puoi ancora mantenere la velocità che hai acquisito se vengono passati i puntatori appropriati in quanto non dovresti incorrere in nessun errore nella cache che non avevi già. Ma tieni a mente le ramificazioni condizionali mentre procedi.

Se stai utilizzando un'altra lingua, potresti avere successo nell'applicare alcuni insegnamenti di Martin Fowler ( link , link ).

The split loop is an often used performance optimisation in data intensive applications. When you are accessing to separate arrays in the same loop you can get hit badly by the cache misses. That is, if the arrays are large enough you loose locality of reference and the cache fails to do the job. Put enough code here and every operation will not hit the cache and instead have to go back out to main memory.

By splitting loops up into small separate components that only act on one array you get significant performance increases. In rendering code I've seen up to an order of magnitude difference. This is particularly beneficial if it is primitive type based and less so if class reference or pointer based where you need an additional dereference off into a random memory location. This technique is also very similar to loop unravelling for performance gains (although something I doubt would ever appear in a refactoring/patterns/OO type book :)

L'ultimo suggerimento sta tentando di semplificare la tua espressione usando la logica o determinando se c'è qualche struttura dati che meglio si adatta al tuo calcolo nell'aspetto della leggibilità.

Se ci sono una serie di controlli complessi o calcoli concatenati per logica, allora dai a ciascuno un nome descrittivo in modo che lo scopo sia chiaro.

Private Function CheckDateEntry(int day, int month, int year)
  If DayIsValid(day) And MonthIsValid(month) And YearIsValid(year)
    Return True
  End If 
End Function

Piuttosto che:

Private Function CheckUserInput(int d, int m, int y)
  If (d > 0 and d <= 31) and (m > 0 and m <= 12) and (y > 0 and y <= 2015)
    Return True
  End If
End Function

Se puoi, rompere la routine in routine più piccole (testabili). Gli sviluppatori hanno molta più fiducia in un pezzo di codice se ci sono una serie di test automatici per questo.

Assicurati che le tue routine e le tue variabili seguano una convenzione ragionevole. Quindi verbo-sostantivo per metodi e nomi per variabili.

Nella tua ricerca di rendere il codice il più veloce possibile, sembra che sia stata sacrificata la leggibilità del codice, che a volte è la norma per il corso. Tuttavia, se il codice non è chiaro a causa di ciò in alcuni punti, prendere in considerazione l'aggiunta di commenti pertinenti.