Ne zaman açık bir dönüş ifadesi Groovy yazmak için?

21

Şu anda bir Groovy / Grails projesi üzerinde çalışıyorum (ki bu oldukça yeniyim) ve returnGroovy yöntemlerinde anahtar kelimeyi atlamanın iyi bir uygulama olup olmadığını merak ediyorum . Bildiğim kadarıyla açıkça nöbet yan tümceleri için anahtar kelime eklemek zorunda, yani biri başka her yerde de kullanmalı? Bence ek returnanahtar kelime okunabilirliği artırıyor. Yoksa alışmanız gereken bir şey mi? Bu konuyla ilgili deneyiminiz nedir?

Bazı örnekler:

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
kaynak

Perl'de benzer bir sorun var: bir işlev, bir returnifade yokluğunda son değerlendirilen ifadeyi döndürür . Şahsen ben her zaman açık olanı kullanıyorum return, ama Groovy'yi bilmiyorum.

— Keith Thompson

2

Şahsen dolaylı olarak return sadece tamamen açık olduğunda kullanırım. toStringtipik bir örnektir: tek astarlıdır ve hesaplanan değer açıkça dönüş değeridir. Ama sonra tekrar, bunun büyük topluluğun düşüncelerine uyup uymadığını bilmek için yeterince Groovy programlamamıştım.

— Joachim Sauer

7

Niyetin daha sonra gelip kodunu güncelleyebileceği / koruyabileceği (kendiniz dahil) herhangi bir kişiye niyeti daha açık hale getirdiği için dönüşü ekleyeceğim.

Aksi takdirde bir yazma hatası gibi görünebilir.

Diğer bir şey, bir boşluğu 'boşluk' olarak döndürmesi beklenen işlevleri / kapanışları bildirmeyi hatırlamaktır - yine gelecekteki bakıcılara ne yapmaya çalıştığınızı daha açık hale getirmek için.

— adrianmcmenamin
kaynak

17

Berraklık kraldır.

Kodunuzu yazdıktan sonra okumak zorunda olan programcı için en açık olanı yapın.

— Robert Harvey
kaynak

8

İşte dönüş ifadelerini atlamak için bir argüman ( Kaynak ):

Groovy'de Sade Bir Özellik

Arka fon

Bir süredir Groovy ile çalıştım, ancak bir özelliğe ters oldum: değerlendirilen son ifadenin örtük dönüşü. Örneğin:

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

Yukarıdaki kodda, bana daha güvenli hissettim çünkü dönüş kullanın. Eric'in gönderisine katılma eğilimindeydim (açık iadelerle ilgili olarak).

Vahiy

Şimdi anladım ve hepsi Groovy'deki gelişmiş toplama yöntemleri sayesinde.

Toplama yöntemini düşünün. Bir işlevi uygulayarak bir listeyi dönüştürür. Sözde kodda:

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

Bunu göz önünde bulundurarak, başka bir örnek:

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

Fikir basitçe bir dizgi listesinden Composer nesnelerinin bir listesini oluşturmaktır. Yorumda belirtildiği gibi, toplamak için geçen kapak, büyük etkiye örtük dönüşü kullanır. Bir keresinde, bu fikri ifade etmek için 3-4 satır alırdım.

Ama şimdi, bu kod sadece özlü değil: gerçekten zarif. Python gibi diğer dilleri çok andırıyor.

Eve Dönüş Mesajı

Mükemmel Groovy özelliklerinin birçok listesi var. Ancak 'örtük getirinin' nadiren listelendiğini görüyoruz. Ben bir hayranım: Diğer özellikler için tekerlekleri yağlar.

Birçok dilde mevcut olduğunu anlıyorum: Groovy'de henüz kullanmadım. Birkaç hafta içinde onsuz yaşayamayacağımdan şüpheleniyorum.

— Çad
kaynak