Ruby'de açıkça geri dönmek iyi bir stil mi?

Stil söz konusu olduğunda her zaman "bunu yapmanın doğru yolu" ("Pythonic" yolu) olan bir Python arka planından geliyorum, Ruby için de bunun olup olmadığını merak ediyorum. Kendi stil yönergelerimi kullanıyorum, ancak kaynak kodumu serbest bırakmayı düşünüyorum ve var olabilecek yazılı olmayan kurallara uymasını istiyorum.

Açıkça returnyöntemlerle yazmak "Ruby Way" mi? Yaptım ve yapmadım gördüm, ama bunu yapmanın doğru bir yolu var mı? Bunu yapmak için belki doğru zaman var mı? Örneğin:

def some_func(arg1, arg2, etc)
  # Do some stuff...
  return value # <-- Is the 'return' needed here?
end

Eski (ve "cevaplandı") sorusu, ama cevap olarak iki sentime atılacağım.

TL; DR - Zorunda değilsiniz, ancak bazı durumlarda kodunuzu çok daha net hale getirebilir.

Açık bir dönüş kullanmamak "Ruby yolu" olsa da, tanıdık kodla çalışan veya Ruby'nin bu özelliğine aşina olmayan programcılar için kafa karıştırıcıdır.

Biraz çelişkili bir örnek, ancak geçen sayıya bir ekleyen ve bir örnek değişkenine atayan böyle küçük bir işleve sahip olduğunuzu düşünün.

def plus_one_to_y(x)
    @y = x + 1
end

Bu bir değer döndüren bir işlev miydi, değil miydi? Her ikisi de örnek değişkenini atadığı için VE geliştiricinin ne anlama geldiğini söylemek gerçekten zor VE atanan değeri de döndürüyor.

Çok daha sonra, başka bir programcı (belki de Ruby'nin yürütülen son kod satırına göre nasıl döndüğüne aşina olmadığı) varsayalım ve günlüğe kaydetmek için bazı yazdırma ifadeleri koymak istiyor ve işlev bu hale geliyor ...

def plus_one_to_y(x)
    @y = x + 1
    puts "In plus_one_to_y"
end

Şimdi bir şey döndürülen bir değer bekliyorsa işlev bozulur . Hiçbir şey döndürülen bir değer beklemiyorsa, sorun olmaz. Kod zincirinin aşağısında bir yerde, bunu çağıran bir şey döndürülen bir değer bekliyorsa, beklediği şeyi geri almadığı için başarısız olacaktır.

Şimdi asıl soru şudur: bir şey gerçekten döndürülen bir değer bekliyor muydu? Bu bir şey mi kırdı yoksa değil mi? Gelecekte bir şey kıracak mı? Kim bilir! Tüm aramaların yalnızca tam kod incelemesi size bildirir.

Bu yüzden en azından benim için en iyi uygulama yaklaşımı ya bir şeyi önemliyse iade ettiğinizin çok açık olması ya da hiç olmadığı zaman hiçbir şey döndürmemenizdir.

Bu yüzden küçük demo fonksiyonumuzda, bir değer döndürmesini istediğimizi varsayarsak, bu şekilde yazılır ...

def plus_one_to_y(x)
    @y = x + 1
    puts "In plus_one_to_y"
    return @y
end

Ve herhangi bir programcı için bir değer döndürdüğü çok açıktır ve farkında olmadan onu kırmaları çok daha zordur.

Alternatif olarak, bu şekilde yazılabilir ve dönüş ifadesini bırakabilir ...

def plus_one_to_y(x)
    @y = x + 1
    puts "In plus_one_to_y"
    @y
end

Ama neden kelime dönüşünü bırakarak zahmet ediyorsunuz? Neden sadece oraya koyup neler olduğunu% 100 netleştirmiyorsunuz? Kodunuzun gerçekleştirme yeteneği üzerinde hiçbir etkisi olmayacaktır.

Hayır. İyi Yakut stili genellikle erken dönüş için yalnızca açık bir dönüş kullanır . Ruby kod minimalizminde / örtük büyüde büyüktür.

Bununla birlikte, açık bir geri dönüş işleri daha net veya daha kolay hale getirirse, hiçbir şeye zarar vermez.

Ben şahsen fonksiyonel yöntemlerreturn dediğim , yani esas olarak dönüş değeri için yürütülen yöntemler ve birincil olarak yan etkileri için yürütülen prosedür yöntemleri arasında ayrım yapmak için anahtar kelimeyi kullanın . Dolayısıyla, dönüş değerinin önemli olduğu yöntemler, dönüş değerine dikkat çekmek için fazladan bir anahtar kelime edinin .return

Yöntemleri çağırırken aynı ayrımı kullanıyorum : fonksiyonel yöntemler parantez alır, yordamsal yöntemler kullanmaz.

Ve son fakat aynı derecede önemli olarak, bu ayrımı bloklarla da kullanıyorum: fonksiyonel bloklar kıvırcık parantezler, prosedür blokları (yani "bir şey yapan" bloklar) olsun do/ end.

Ancak, bu konuda dini olmaya çalışmıyorum: bloklarla, kıvırcık parantezlerle ve do/ endfarklı önceliğe sahip ve bir ifadeyi belirsizleştirmek için açık parantez eklemek yerine, sadece diğer stile geçiyorum. Aynı yöntem çağırma için de geçerlidir: parametre listesi etrafında parantez eklemek kodu daha okunabilir hale getirirse, söz konusu yöntem doğada prosedürel olsa bile bunu yaparım.

Aslında önemli olan aşağıdakileri ayırt etmektir:

1. İşlevler - dönüş değerleri için yürütülen yöntemler
2. Prosedürler - yan etkileri için uygulanan yöntemler

Ruby'nin bunları ayırt etmenin yerel bir yolu yoktur - bu sizi bir prosedür yazmaya karşı savunmasız bırakır side_effect()ve başka bir geliştirici prosedürünüzün örtük dönüş değerini kötüye kullanmaya karar verir (temel olarak onu saf olmayan bir işlev olarak ele alır).

Bunu çözmek için Scala ve Haskell'in kitabından bir yaprak alın ve prosedürlerinizin açıkça nil( diğer dillerde Unitveya ()diğer dillerde) geri alınmasını sağlayın .

Bunu izlerseniz, açık returnsözdizimini kullanmak veya kullanmak kişisel bir stil meselesi haline gelir.

İşlevler ve prosedürler arasında daha fazla ayrım yapmak için:

1. Jörg W Mittag'in işlevsel blokları kıvırcık parantezlerle ve prosedür bloklarını do/end
2. Yordamları ()çağırırken işlevlerini çağırırken,

Kaçınarak - Jörg W Mittag aslında tersi savunduğu o Not ()ler prosedürler için - ama yan etkileyen yöntem invocations Arity 0. Bkz olduğu zaman, değişkenler açıkça ayırt olmak istiyorum çünkü tavsiye edilmez yöntem çağırma üzerinde Scala stil kılavuzu için detaylar.

Stil rehberi , returnson ifadenizde kullanmamanız gerektiğini belirtir . Sonuncusu değilse yine de kullanabilirsiniz . Bu, topluluğun sıkı bir şekilde takip ettiği sözleşmelerden biridir ve bu yüzden Ruby kullanan herhangi biriyle işbirliği yapmayı planlıyorsanız.

Bununla birlikte, açık returns kullanmanın ana argümanı , diğer dillerden gelen insanlar için kafa karıştırıcı olmasıdır.

• İlk olarak, bu tamamen Ruby'ye özel değildir. Örneğin, Perl'in örtülü dönüşleri de vardır.
• İkincisi, bunun geçerli olduğu insanların çoğunluğu Algol dillerinden geliyor. Bunların çoğu Ruby'den "düşük seviye" dir , bu nedenle bir şeyler yapmak için daha fazla kod yazmanız gerekir.

Java'da yöntem uzunluğu (alıcılar / ayarlayıcılar hariç) için ortak bir sezgisel tarama bir ekrandır . Bu durumda, yöntem tanımını görmüyor olabilirsiniz ve / veya nereden döndüğünüzü unutmuş olabilirsiniz.

Öte yandan, Ruby'de 10 satırdan daha kısa yöntemlere bağlı kalmak en iyisidir . Bunu göz önüne alındığında, açıkça ima edildiğinde neden ~% 10 daha fazla ifade yazması gerektiği merak edilebilir.

Ruby geçersiz yöntemlere sahip olmadığından ve her şey çok daha özlü olduğu için, açık returns ile giderseniz hiçbir fayda için ek yük eklersiniz .

Ben Hughes ile aynı fikirdeyim ve Tim Holt ile aynı fikirde değilim, çünkü soru Python'un yaptığı gibi kesin bir şekilde bahsediyor ve Ruby'nin benzer bir standarda sahip olup olmadığını soruyor.

Öyle.

Bu, dilin çok iyi bilinen bir özelliğidir, yakutta bir sorunu ayıklaması beklenen herkesin bu konuda makul bir şekilde bilmesi beklenir.

Çoğunlukla hangi stili tercih edeceğiniz meselesi. Bir yöntemin ortasında bir yerden dönmek istiyorsanız return anahtar sözcüğünü kullanmanız gerekir.

Ben'in dediği gibi. 'Yakut yöntemin dönüş değerinin işlev gövdesindeki son ifadenin dönüş değeri olması' dönüş anahtar kelimesinin çoğu yakut yöntemde nadiren kullanılmasına neden olur.

def some_func_which_returns_a_list( x, y, z)
  return nil if failed_some_early_check


  # function code 

  @list     # returns the list
end