qual è il punto di ritorno in Ruby?

Qual è la differenza tra il return e l’inserimento di una variabile come la seguente:

senza ritorno

 def write_code(number_of_errors) if number_of_errors > 1 mood = "Ask me later" else mood = "No Problem" end mood end 

ritorno

 def write_code(number_of_errors) if number_of_errors > 1 mood = "Ask me later" else mood = puts "No Problem" end return mood end 

return ti permette di uscire presto:

 def write_code(number_of_errors) return "No problem" if number_of_errors == 0 badness = compute_badness(number_of_errors) "WHAT?! Badness = #{badness}." end 

Se number_of_errors == 0 , quindi "No problem" verrà restituito immediatamente. Alla fine di un metodo, però, non è necessario, come hai osservato.


Modifica: per dimostrare che il return termina immediatamente, considera questa funzione:

 def last_name(name) return nil unless name name.split(/\s+/)[-1] end 

Se chiami questa funzione come last_name("Antal SZ") , restituirà "SZ" . Se lo chiami come last_name(nil) , restituisce nil . Se return non interrompesse immediatamente, proverebbe ad eseguire nil.split(/\s+/)[-1] , che genererebbe un errore.

L’uso di “return” non è necessario se è l’ultima riga da eseguire nel metodo, poiché Ruby restituisce automaticamente l’ultima espressione valutata.

Non hai nemmeno bisogno di quel “mood” finale, né hai bisogno di questi incarichi nella dichiarazione IF.

 def write_code(number_of_errors) if number_of_errors > 1 "ERROR" else "No Problem" end end puts write_code(10) 

Produzione:

ERRORE

Ruby torna sempre! il modo migliore è

 def write_code(number_of_errors) (number_of_errors > 1)? "ERROR" : "No Problem" end 

significa che se number_of_errors> 1 restituirà ERROR else No Problem

Uso return quando sto esaminando una lista e voglio uscire dalla funzione se qualche membro della lista soddisfa un criterio. Potrei realizzare questo con una singola affermazione come:

list.select{|k| k.meets_criteria}.length == 0

in alcune situazioni, ma

list.each{|k| return false if k.meets_criteria}

è anche una linea – con, a mio parere, una certa flessibilità. Ad esempio, il primo esempio presuppone che questa sia l’unica linea nel metodo e che vogliamo tornare da questo punto, a prescindere da cosa. Ma se questo è un test per vedere se è sicuro procedere con il resto del metodo, il primo esempio dovrà gestirlo in un modo diverso.

MODIFICARE:

Per aggiungere un po ‘di flessibilità, prendere in considerazione la seguente riga di codice:

list_of_method_names_as_symbols.each{|k| list_of_objects.each{|j| return k if j.send(k)}}

Sono sicuro che questo può essere realizzato, in una linea, senza return , ma dalla cima della mia testa non vedo come.

Ma questa è ora una linea di codice abbastanza flessibile che può essere chiamata con qualsiasi elenco di metodi booleani e un elenco di oggetti che implementano questi metodi.

MODIFICARE

Va notato che sto assumendo che questa linea sia all’interno di un metodo, non un blocco.


Ma questa è soprattutto una scelta stilistica, penso che nella maggior parte delle situazioni, è ansible e possibilmente si dovrebbe evitare di utilizzare il return .

Il suo bel ruby offre questa buona caratteristica di non specificare esplicitamente la dichiarazione di ritorno, ma mi sembra che, come standard di programmazione, si debba sempre cercare di specificare le dichiarazioni di “ritorno” laddove richiesto. Questo aiuta a rendere il codice più leggibile per qualcuno che proviene da background diversi come C ++, Java, PHP ecc. E sta imparando il ruby. la dichiarazione “return” non danneggerà nulla, quindi perché saltare il modo convenzionale e più standard di tornare dalle funzioni.

L’incoerenza del return all’ultima riga in funzione è solo zucchero sintattico di Ruby. Nella maggior parte dei linguaggi procedurali è necessario scrivere il return in ciascuna funzione (non vuota in C ++).