Sono interessato a quale approccio preferire. Prendi in considerazione un codice che recupera una traduzione per un testo. Deve rispettare questi vincoli:
- Restituisce la traduzione solo se il testo verrà utilizzato su un'interfaccia utente. Se è usato in qualche altro posto (log di debug), restituisce la versione normalizzata del testo.
- La normalizzazione del testo è costosa (risorse della cpu). Dovremmo farlo solo quando è richiesto.
- Anche il caricamento della traduzione è costoso.
- Se la traduzione per il testo è mancante o vuota, restituisci anche il testo originale normalizzato.
Primo approccio:
boolean useFallback = true;
if (textUsedForUi()) {
final String translation = getNonEmptyTranslation(text);
if (translation != null) {
result.setText(translation);
useFallback = false;
}
}
if (useFallback) {
result.setText(normalize(text));
}
String getNonEmptyTranslation(String text) {
String translation = loadTranslation(text);
if (StringUtils.isBlank(translation)) {
return null;
} else {
return translation;
}
}
Secondo approccio:
String translation = getTranslation(text);
if (translation != null) {
result.setText(translation);
} else {
result.setText(normalize(text));
}
String getTranslation(String text) {
if (!textUsedForUi()) {return null;}
String translation = loadTranslation(text);
if (StringUtils.isBlank(translation)) {
return null;
} else {
return translation;
}
}
Il primo approccio indica chiaramente che la traduzione dipende da dove verrà utilizzato il testo e se è disponibile una traduzione. Ma devo introdurre una variabile helper per evitare la duplicazione del codice e assegnazioni non raccomandabili in condizioni:
String translation;
if (textUsedForUi() && (translation = getNonEmptyTranslation(text)) != null)
Non voglio fare affidamento sul valore precedente di result.getText()
, quindi non posso utilizzarlo come flag se utilizzare o meno il fallback.
Il secondo approccio è chiaramente più semplice (riduzione della complessità ciclomatica). Ma nasconde la dipendenza da dove il testo è usato in una sub routine. Ciò riduce la natura di auto-documentazione del codice.
Quale approccio preferire?