Quando escrever uma declaração de retorno explícita no Groovy?

21

No momento, estou trabalhando em um projeto Groovy / Grails (no qual sou bastante novo) e me pergunto se é uma boa prática omitir a returnpalavra - chave nos métodos Groovy. Tanto quanto eu sei que você deve inserir explicitamente a palavra-chave, ou seja, para cláusulas de guarda, deve-se usá-la também em qualquer outro lugar? Na minha opinião, a returnpalavra-chave adicional aumenta a legibilidade. Ou é algo que você só precisa se acostumar? Qual a sua experiência com esse tópico?

Alguns exemplos:

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

Existe um problema semelhante no Perl: uma função retorna a última expressão avaliada na ausência de uma returninstrução. Pessoalmente, eu sempre uso o explícito return, mas não conheço o Groovy.

— Keith Thompson

2

Pessoalmente, eu usaria o implícito return apenas quando estiver perfeitamente claro. toStringé um exemplo típico: é uma linha e o valor calculado é obviamente o valor de retorno. Mas, novamente, eu não programei Groovy suficiente para saber se isso se encaixa no que a comunidade maior pensa.

— Joachim Sauer

7

Eu certamente acrescentaria o retorno, pois torna a intenção mais clara para qualquer pessoa (inclusive você) que possa vir e atualizar / manter o código posteriormente.

Caso contrário, pode parecer um erro de digitação.

A outra coisa é lembrar de declarar funções / fechamentos que devem retornar um vazio como 'vazio' - novamente para tornar mais claro aos futuros mantenedores o que você está tentando fazer.

— adrianmcmenamin
fonte

17

Clareza é rei.

Faça o que estiver mais claro para o colega programador que precisa ler seu código depois de escrevê-lo.

— Robert Harvey
fonte

8

Aqui está um argumento para omitir as instruções de retorno ( fonte ):

Um recurso discreto no Groovy

fundo

Eu trabalhei com o Groovy por um tempo, mas fui avesso a um recurso: o retorno implícito da última expressão avaliada. Por exemplo:

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

No código acima, eu usaria return porque me parecia mais seguro. Eu tendia a concordar com o post de Eric (com relação a retornos explícitos).

Revelação

Eu entendo agora, e tudo isso graças aos métodos aprimorados de coleta no Groovy.

Considere o método de coleta. Ele transforma uma lista aplicando uma função. No pseudocódigo:

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

Com isso em mente, aqui está outro exemplo:

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

A idéia é simplesmente criar uma lista de objetos do Composer a partir de uma lista de strings. Conforme observado no comentário, o fechamento passado para coletar usa o retorno implícito com grande efeito. Ao mesmo tempo, eu usaria 3-4 linhas para expressar essa ideia.

Mas agora, esse código não é apenas conciso: é realmente elegante. Muito reminiscente de outras linguagens como Python.

A mensagem para levar para casa

Existem muitas listas de excelentes recursos do Groovy. No entanto, raramente vemos 'retorno implícito' listado. Sou fã: lubrifica as rodas para outros recursos.

Sei que ele está disponível em vários idiomas: simplesmente não o usei no Groovy. Suspeito que daqui a algumas semanas não poderei viver sem ele.

— Chade
fonte