Quando scrivere una dichiarazione di ritorno esplicita in Groovy?

21

Al momento sto lavorando a un progetto Groovy / Grails (di cui sono abbastanza nuovo) e mi chiedo se sia buona pratica omettere la returnparola chiave nei metodi Groovy. Per quanto ne so, devi inserire esplicitamente la parola chiave, ad esempio per le clausole di guardia, quindi dovresti usarla anche altrove? Secondo me la returnparola chiave aggiuntiva aumenta la leggibilità. O è qualcosa a cui devi solo abituarti? Qual è la tua esperienza con questo argomento?

Qualche esempio:

def foo(boolean bar) {
    // Not consistent
    if (bar) {
        return positiveBar()
    }
    negativeBar()
}

def foo2() {
    // Special Grails example
    def entitiy = new Entity(foo: 'Foo', bar: 'Bar')
    entity.save flush: true
    // Looks strange to me this way
    entity
}

coding-style groovy

— Roland Schneider
fonte

C'è un problema simile in Perl: una funzione restituisce l'ultima espressione valutata in assenza di returnun'istruzione. Personalmente, utilizzo sempre l'esplicito return, ma non conosco Groovy.

— Keith Thompson,

2

Personalmente userei l'implicito return solo quando è perfettamente chiaro. toStringè un tipico esempio: è un liner e il valore calcolato è ovviamente il valore di ritorno. Ma ancora una volta, non ho programmato abbastanza Groovy per sapere se ciò si adatta a ciò che pensa la comunità più ampia.

— Joachim Sauer,

7

Sicuramente aggiungerei il reso, in quanto rende più chiara l'intenzione a qualsiasi persona (incluso te stesso) che potrebbe venire e aggiornare / mantenere il codice in seguito.

Altrimenti potrebbe sembrare un errore di battitura.

L'altra cosa è ricordare di dichiarare funzioni / chiusure che dovrebbero restituire un vuoto come "vuoto", ancora una volta per rendere più chiaro ai futuri manutentori ciò che si sta tentando di fare.

— adrianmcmenamin
fonte

17

La chiarezza è re.

Fai ciò che è più chiaro al collega programmatore che deve leggere il tuo codice dopo averlo scritto.

— Robert Harvey
fonte

8

Ecco un argomento per omettere le dichiarazioni di ritorno ( Fonte ):

Una caratteristica discreta in Groovy

sfondo

Ho lavorato con Groovy per un po ', ma sono stato contrario a una caratteristica: il ritorno implicito dell'ultima espressione valutata. Per esempio:

def getFoo() {
  def foo = null
  if (something) {
    foo = new Foo()
  }
  foo // no 'return' necessary
}

Nel codice sopra, userei return perché mi sembrava più sicuro. Ho avuto la tendenza a concordare con il post di Eric (rispetto ai resi espliciti).

Rivelazione

Ora capisco, ed è tutto grazie ai metodi di raccolta avanzati in Groovy.

Considera il metodo di raccolta. Trasforma un elenco applicando una funzione. In pseudocodice:

[ a, b, c, d] => [ f(a), f(b), f(c), f(d) ]

Con questo in mente, ecco un altro esempio:

class Composer {
  def name
  // def era, etc
}

def list = [ 'Bach', 'Beethoven', 'Brahms' ]

// the closure returns the new Composer object, as it is the last
// expression evaluated.

def composers = list.collect { item -> new Composer(name : item) }

assert 'Bach' == composers[0].name

L'idea è semplicemente quella di creare un elenco di oggetti Composer da un elenco di stringhe. Come notato nel commento, la chiusura passata alla raccolta utilizza il ritorno implicito con grande efficacia. Un tempo avrei preso 3-4 righe per esprimere quell'idea.

Ma ora, questo codice non è semplicemente conciso: è davvero elegante. Ricorda molto altre lingue come Python.

Il messaggio da portare a casa

Ci sono molti elenchi di eccellenti funzionalità di Groovy. Tuttavia raramente vediamo il "ritorno implicito" elencato. Sono un fan: ingrassa le ruote per altre caratteristiche.

Mi rendo conto che è disponibile in molte lingue: non l'ho mai usato in Groovy. Sospetto che tra qualche settimana non sarò in grado di vivere senza di essa.

— Chad
fonte