Quando scrivere una dichiarazione di reso esplicita in Groovy?

17

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

Alcuni esempi:

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
}
    
posta Roland Schneider 11.06.2012 - 19:38
fonte

3 risposte

5

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

Altrimenti potrebbe sembrare un errore di battitura.

L'altra cosa è ricordare di dichiarare funzioni / chiusure che si prevede che restituiscano un vuoto come "vuoto" - di nuovo per rendere più chiaro ai futuri manutentori cosa stai cercando di fare.

    
risposta data 19.06.2012 - 16:41
fonte
15

La chiarezza è il re.

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

    
risposta data 14.06.2012 - 18:09
fonte
8

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

An Understated Feature in Groovy

Background

I have worked with Groovy for awhile, but have been averse to one feature: the implicit return of the last expression evaluated. For example:

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

In the above code, I would use return because it felt safer to me. I tended to agree with Eric's post (with respect to explicit returns).

Revelation

I get it now, and it's all thanks to the enhanced collection methods in Groovy.

Consider the collect method. It transforms a list by applying a function. In pseudocode:

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

With that in mind, here's another example:

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

The idea is simply to build a list of Composer objects from a list of strings. As noted in the comment, the closure passed to collect uses the implicit return to great effect. At one time, I would have taken 3-4 lines to express that idea.

But now, this code is not merely concise: it is truly elegant. Very reminiscent of other languages such as Python.

The Take-Home Message

There are many lists of excellent Groovy features. However we rarely see 'implicit return' listed. I'm a fan: it greases the wheels for other features.

I realize it is available in many languages: I just haven't used it in Groovy. I suspect in a few weeks I won't be able to live without it.

    
risposta data 17.07.2012 - 17:43
fonte

Leggi altre domande sui tag