Apakah gaya yang baik untuk kembali secara eksplisit di Ruby?

Berasal dari latar belakang Python, di mana selalu ada "cara yang tepat untuk melakukannya" (cara "Pythonic") ketika datang ke gaya, saya bertanya-tanya apakah hal yang sama ada untuk Ruby. Saya telah menggunakan pedoman gaya saya sendiri tetapi saya berpikir untuk merilis kode sumber saya, dan saya ingin mematuhi aturan tidak tertulis yang mungkin ada.

Apakah itu "The Ruby Way" untuk secara eksplisit mengetikkan returnmetode? Saya sudah melihatnya selesai dengan dan tanpa, tetapi apakah ada cara yang tepat untuk melakukannya? Apakah mungkin ada waktu yang tepat untuk melakukannya? Sebagai contoh:

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

Pertanyaan lama (dan "dijawab"), tetapi saya akan melemparkan dua sen saya sebagai jawaban.

TL; DR - Anda tidak harus melakukannya, tetapi itu bisa membuat kode Anda jauh lebih jelas dalam beberapa kasus.

Meskipun tidak menggunakan pengembalian eksplisit mungkin "cara Ruby", itu membingungkan bagi programmer yang bekerja dengan kode asing, atau tidak terbiasa dengan fitur Ruby ini.

Ini adalah contoh yang agak dibuat-buat, tetapi bayangkan memiliki fungsi kecil seperti ini, yang menambahkan satu ke angka yang lewat, dan menugaskannya ke variabel instan.

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

Apakah ini dimaksudkan sebagai fungsi yang mengembalikan nilai, atau tidak? Sangat sulit untuk mengatakan apa yang dimaksud pengembang, karena keduanya memberikan variabel instan, DAN mengembalikan nilai yang ditetapkan juga.

Misalkan nanti, programmer lain (mungkin tidak terlalu familiar dengan bagaimana Ruby mengembalikan berdasarkan baris terakhir dari kode yang dieksekusi) datang dan ingin memasukkan beberapa pernyataan cetak untuk logging, dan fungsinya menjadi seperti ini ...

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

Sekarang fungsinya rusak jika ada yang mengharapkan nilai yang dikembalikan . Jika tidak ada yang mengharapkan nilai yang dikembalikan, tidak apa-apa. Jelas jika suatu tempat lebih jauh ke bawah rantai kode, sesuatu yang memanggil ini mengharapkan nilai yang dikembalikan, itu akan gagal karena tidak mendapatkan kembali apa yang diharapkan.

Pertanyaan sebenarnya sekarang adalah ini: apakah ada yang benar-benar mengharapkan nilai yang dikembalikan? Apakah ini merusak sesuatu atau tidak? Akankah itu merusak sesuatu di masa depan? Siapa tahu! Hanya tinjauan kode lengkap dari semua panggilan yang akan memberi tahu Anda.

Jadi bagi saya setidaknya, pendekatan praktik terbaik adalah dengan sangat eksplisit bahwa Anda mengembalikan sesuatu jika itu penting, atau tidak menghasilkan apa-apa sama sekali ketika tidak.

Jadi dalam kasus fungsi demo kecil kami, dengan asumsi kami ingin mengembalikan nilai, itu akan ditulis seperti ini ...

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

Dan akan sangat jelas bagi setiap programmer bahwa ia mengembalikan nilai, dan jauh lebih sulit bagi mereka untuk memecahkannya tanpa menyadarinya.

Atau, orang dapat menulis seperti ini dan meninggalkan pernyataan kembali ...

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

Tapi mengapa repot-repot meninggalkan kata kembali? Mengapa tidak letakkan saja di sana dan buatlah 100% jelas apa yang terjadi? Ini benar-benar tidak akan berdampak pada kemampuan kode Anda untuk melakukan.

Tidak. Gaya Ruby yang baik umumnya hanya menggunakan pengembalian eksplisit untuk pengembalian awal . Ruby besar pada kode minimalisme / sihir implisit.

Yang mengatakan, jika pengembalian eksplisit akan membuat segalanya lebih jelas, atau lebih mudah dibaca, itu tidak akan membahayakan apa pun.

Saya pribadi menggunakan returnkata kunci untuk membedakan antara apa yang saya sebut metode fungsional , yaitu metode yang dieksekusi terutama untuk nilai pengembaliannya, dan metode prosedural yang dieksekusi terutama untuk efek sampingnya. Jadi, metode di mana nilai kembali itu penting, dapatkan returnkata kunci tambahan untuk menarik perhatian pada nilai balik.

Saya menggunakan perbedaan yang sama ketika memanggil metode: metode fungsional mendapatkan tanda kurung, metode prosedural tidak.

Dan last but not least, saya juga menggunakan perbedaan itu dengan blok: blok fungsional mendapatkan kurung kurawal, blok prosedural (yaitu blok yang "melakukan" sesuatu) dapatkan do/ end.

Namun, saya mencoba untuk tidak menjadi religius tentang hal itu: dengan balok, kurung kurawal dan do/ endmemiliki prioritas yang berbeda, dan alih-alih menambahkan tanda kurung eksplisit untuk mengaburkan ekspresi, saya hanya beralih ke gaya lain. Hal yang sama berlaku untuk pemanggilan metode: jika menambahkan tanda kurung di sekitar daftar parameter membuat kode lebih mudah dibaca, saya melakukannya, bahkan jika metode tersebut bersifat prosedural.

Sebenarnya yang penting adalah membedakan antara:

1. Fungsi - metode yang dieksekusi untuk nilai pengembaliannya
2. Prosedur - metode yang dilakukan untuk efek sampingnya

Ruby tidak memiliki cara asli untuk membedakan ini - yang membuat Anda rentan untuk menulis prosedur side_effect()dan pengembang lain memutuskan untuk menyalahgunakan nilai balik implisit dari prosedur Anda (pada dasarnya memperlakukannya sebagai fungsi tidak murni).

Untuk mengatasinya, keluarkan daun dari buku Scala dan Haskell dan minta prosedur Anda dikembalikan secara eksplisit nil(alias Unitatau ()dalam bahasa lain).

Jika Anda mengikuti ini, maka menggunakan returnsintaksis eksplisit atau tidak hanya menjadi masalah gaya pribadi.

Untuk membedakan lebih jauh antara fungsi dan prosedur:

1. Salin ide bagus Jörg W Mittag untuk menulis blok fungsional dengan kurung kurawal, dan blok prosedural dengan do/end
2. Saat Anda menjalankan prosedur, gunakan (), sedangkan saat Anda menjalankan fungsi, jangan

Perhatikan bahwa Jörg W Mittag sebenarnya menganjurkan sebaliknya - menghindari ()untuk prosedur - tetapi itu tidak dianjurkan karena Anda ingin invokasi metode efek samping secara jelas dapat dibedakan dari variabel, terutama ketika arity adalah 0. Lihat panduan gaya Scala tentang metode doa untuk detail.

Panduan gaya menyatakan, bahwa Anda tidak boleh menggunakan returnpada pernyataan terakhir Anda. Anda masih dapat menggunakannya jika itu bukan yang terakhir . Ini adalah salah satu konvensi yang diikuti oleh komunitas dengan ketat, dan Anda juga harus jika Anda berencana untuk berkolaborasi dengan siapa pun yang menggunakan Ruby.

Yang sedang berkata, argumen utama untuk menggunakan returns eksplisit adalah bahwa itu membingungkan bagi orang-orang yang datang dari bahasa lain.

• Pertama, ini tidak sepenuhnya eksklusif untuk Ruby. Misalnya Perl juga memiliki pengembalian implisit.
• Kedua, mayoritas orang yang menerapkan ini berasal dari bahasa Algol. Sebagian besar cara "tingkat lebih rendah" dari Ruby, maka Anda harus menulis lebih banyak kode untuk menyelesaikan sesuatu.

Heuristik umum untuk panjang metode (tidak termasuk getter / setter) di java adalah satu layar . Dalam hal ini, Anda mungkin tidak melihat definisi metode dan / atau sudah lupa dari mana Anda kembali.

Di sisi lain, di Ruby yang terbaik adalah tetap menggunakan metode yang panjangnya kurang dari 10 baris . Mengingat itu, orang akan bertanya-tanya mengapa dia harus menulis ~ 10% lebih banyak pernyataan, ketika mereka jelas tersirat.

Karena Ruby tidak memiliki metode batal dan semuanya jauh lebih ringkas, Anda hanya menambahkan overhead untuk tidak ada manfaat jika Anda menggunakan returns eksplisit .

Saya setuju dengan Ben Hughes dan tidak setuju dengan Tim Holt, karena pertanyaannya menyebutkan cara definitif Python melakukannya dan bertanya apakah Ruby memiliki standar yang sama.

Itu benar.

Ini adalah fitur bahasa yang sangat terkenal sehingga siapa pun yang diharapkan men-debug masalah di ruby ​​harus diharapkan untuk mengetahuinya.

Ini masalah gaya mana yang paling Anda sukai. Anda harus menggunakan kata kunci kembali jika Anda ingin kembali dari suatu tempat di tengah metode.

Seperti kata Ben. Fakta bahwa 'nilai kembali metode ruby ​​adalah nilai balik dari pernyataan terakhir di badan fungsi' menyebabkan kata kunci kembali jarang digunakan dalam sebagian besar metode ruby.

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


  # function code 

  @list     # returns the list
end