inutili 'altro' dichiarazione

Question

Come sapete, in Eclipse è possibile attivare "inutili 'altro' affermazione" verificare che attiveranno sul if-then-else con ritorno prematuro. E, dalla mia esperienza, ci sono due situazioni più possibili quando l'uso tale affermazione:

1) Pre-controllo:

if (!validate(arg1)) { 
    return false; 
} 
doLotOfStuff(); 

2) Post-controllo:

doLotOfStuff(); 
if (condition) { 
    return foo; 
} else { 
    return bar; 
} 

Nella seconda caso, se il trigger è attivo, Eclipse suggerirà di cambiare il codice per:

doLotOfStuff(); 
if (condition) { 
    return foo; 
} 
return bar; 

Tuttavia, penso che t he restituisce con else è più leggibile in quanto è come la mappatura diretta della logica aziendale. Quindi sono curioso se questa convenzione di codice "Inutile 'else' statement" è diffusa o codice con else else è più preferibile?

Answer 1

In genere preferirei che la struttura del codice seguisse la struttura della logica "aziendale" sottostante. In questo caso, il mio approccio dipenderebbe da ciò che rappresenta condition. Se si tratta di un controllo di errore, ad esempio, che normalmente non verrà colpito ma potrebbe essere usato occasionalmente, l'asimmetria della seconda forma corrisponde all'asimmetria della logica.

doLotOfStuff(); 
if (condition) { 
    return foo; 
} 
return bar; 

Ma se una possibilità è ragionevole ed è semplicemente una scelta tra loro, consentirebbe la struttura del codice per mostrare che la simmetria.

doLotOfStuff(); 
if (condition) { 
    return foo; 
} else { 
    return bar; 
} 

Il codice è lì per il programmatore per leggere, non il compilatore.

Answer 2

So che senza l'IDE che verifica questo per me, uso quasi sempre la dichiarazione non necessaria. Spesso trovo che sia meglio leggere inizialmente con esso, ma di solito lo rimuovo quando viene indicato come posso vedere il fatto che non è necessario e quindi mi infastidisce ...

Answer 3

Bene, penso che l'utilizzo di più ritorno sia non leggibile.

preferisco codice come:

String result = null; 

doLotOfStuff(); 
if (condition) { 
    result = foo; 
} else { 
    result = bar; 
} 

return result; 

rendimenti più è complicato da capire. Ma nel tuo caso io preferisco il postCheck

doLotOfStuff(); 
if (condition) { 
    return foo; 
} else { 
    return bar; 
} 

Answer 4

Un tempo era considerato (e probabilmente ancora essere da alcuni) che le funzioni devono avere un punto di ingresso (facile, ma era rilevante se si considera il linguaggio assembly) e una di uscita punto.

Un punto di uscita è bello da un punto di vista di debug (come in è possibile mettere un orologio/interruzione su una riga e sapere che lo si attraversa) ma può portare ad alcuni annidamenti orribili così spesso che la leggibilità non tende a avere la meglio. Quale produce il minimo nidificazione, la minima riga di codice e il risultato finale più leggibile? In definitiva, tende ad essere molto più importante di qualsiasi altra cosa.

Per quello che vale l'ultimo può essere espresso meglio come:

return condition ? foo : bar; 

assumendo condition non è molto lunga.

Non preoccuparti eccessivamente del cosiddetto codice "purezza". È una distrazione irrilevante. Rendere le cose leggibili e in generale essere coerenti.

Answer 5

Alcuni programmatori sostengono che lo return nel mezzo della funzione è una cattiva pratica. Forse per un facile controllo all'ingresso della funzione come nel tuo primo esempio, è OK e accettabile, ma in altri casi preferirei impostare la variabile result come nella risposta di Jerome.

Answer 6

Trovo questa forma

doLotOfStuff(); 
if (condition) { 
    return foo; 
} 
return bar; 

per essere più leggibile di quella con l'altro, è meno codice e più intuitiva, se ci pensate come una dichiarazione di guardia come in refactoring di Fowler.

Question about multiple return points.

Answer 7

Call me un cattivo ragazzo, ma mi sarebbe solito andare con:

doLotOfStuff(); 
return condition ? foo : bar; 

istruzione return singolo, molto leggibile.

Answer 8

Se rintraccio il seguente codice, noterò che il primo if-block è un blocco di codice eccezionale. Tuttavia, se aggiungo un "altro", posso considerare che entrambi sono blocchi di codice operativo.

Inoltre, per il blocco operativo principale, potrebbero essere presenti blocchi nidificati. Preferisco ridurre al minimo il livello annidato.

public String myMethod(input) { 
    if (!validate(input)) { 
     return "invalid input"; 
    } 

    operation1(); 
    if (someCondition) { 
     operation2(); 
    } else { 
     operation3(); 
    } 
    operation4(); 
    operation5(); 
    return operation6(); 
} 

Answer 9

A mio parere, il controllo eclisse non è molto utile. Quello che dovresti fare dipende dal contesto del tuo programma. Le altre clausole sono per alternative (o questo o quello) mentre cadere fino a un ritorno (nessuna clausola else) è più appropriato dove si hanno un certo numero di condizioni che possono essere vere e il fallthrough è più di una reazione di default che non invoca davvero troppo spesso. Quindi tu usi entrambi nel codice che trasmette il significato e in quanto tale il controllo della presenza o dell'assenza non è utile.

Answer 10

Bene, alcuni noti esperti di Java sostengono che si dovrebbe sempre combattere per minimizzare la portata delle cose e questa è anche la mia opinione.

I miei insegnanti di università mi ha sempre tormentato che devo scrivere cose come questa come pubblicato da qualcuno prima:

String result = null; 
doLotOfStuff(); 
if (condition) { 
    result = foo; 
} else { 
    result = bar; 
} 
return result; 

Il risultato variabile ha ora un abbastanza grande portata. Inoltre con un sacco di nidificazione tende a diventare molto illeggibile se fai un po 'di più qui, diciamo che hai un altro ciclo.

Penso che questo sia molto meglio:

doLotOfStuff(); 
return condition ? foo : bar; 

Questo è dritto al punto. Vedo subito cosa sta succedendo, nessun controllo di parentesi graffe.

penso che sia molto buona per

• Ridurre al minimo la portata
• Ridurre al minimo l'indentazione (cioè evitare di parentesi graffe)
• Ridurre al minimo la lunghezza metodo

L'avvertimento "Unnecessary else" aiuta con quello.