Belajar Ruby - Methods, Blocks, Proc & Lambda

#Pendahuluan

Setelah menguasai sintaks dan control flow, saatnya membentuk unit logika yang bisa dipakai ulang: method. Namun Ruby tidak berhenti di method biasa. Bahasa ini menjadikan block sebagai warga kelas satu, sehingga kalian bisa menyisipkan potongan logika ke dalam method lain — inilah yang membuat kode Ruby begitu ekspresif.

Episode 5 ini membedah tiga konsep yang saling terkait: definisi method dengan seluruh gaya parameternya, block beserta yield, serta Proc dan Lambda dengan perbedaan perilakunya yang sering menjebak. Di akhir, kalian akan mengenal Enumerable — modul yang memberikan map, select, dan reduce — inti dari gaya pemrograman fungsional Ruby.

#Mendefinisikan Method

#Parameter Posisional dan Default Value

Method didefinisikan dengan def dan ditutup end. Nama method bisa diakhiri ? (predikat boolean) atau ! (mutasi). Parameter posisional menerima argumen sesuai urutan, dan parameter dengan nilai default bisa dihilangkan saat pemanggilan:

Method dengan parameter

def sapa(nama, salam = "Halo")
  "#{salam}, #{nama}!"
end
 
puts sapa("Arman")
puts sapa("Ruby", "Selamat datang")

Block kode di atas menampilkan Halo, Arman! dan Selamat datang, Ruby!. Perhatikan return implisit: nilai ekspresi terakhir (string hasil interpolasi) otomatis menjadi nilai balik method, tanpa kata kunci return. Pemanggilan sapa("Arman") memakai default "Halo", sementara sapa("Ruby", "Selamat datang") menimpa nilainya.

#Keyword Arguments dan Splat

Ruby mendukung keyword arguments yang tidak bergantung urutan, serta splat untuk menangkap jumlah argumen yang tak tentu. Tanda * menangkap argumen posisional ke array, dan ** menangkap keyword ke hash:

Keyword arguments dan splat

def buat_pengguna(nama:, umur:, role: "user")
  "#{role}: #{nama} (#{umur})"
end
puts buat_pengguna(nama: "Arman", umur: 30)
 
def total(*angka)
  angka.sum
end
puts total(1, 2, 3, 4)

Pemanggilan buat_pengguna(nama: "Arman", umur: 30) memakai keyword nama dan umur wajib, sementara role opsional. Method total(*angka) menerima banyak argumen posisional yang digabung menjadi array, lalu menjumlahkannya. Kedua gaya ini sangat umum di Rails dan gem ternama.

#Block: Logika yang Disisipkan

#do...end dan Kurung Kurawal

Block adalah potongan kode yang dilewatkan ke method dan dieksekusi di dalamnya. Ada dua bentuk penulisan: do...end untuk block multi-baris dan { } untuk satu baris. Konvensinya: pakai { } untuk block yang hasilnya dipakai kembali (seperti map), dan do...end untuk block yang mengeksekusi efek samping (seperti each).

#yield dan &block

Method memanggil block yang diberikan lewat kata kunci yield. Jika ingin block diperlakukan sebagai objek, tangkap dengan parameter &block:

yield dan block

def ulang_kali
  yield
  yield
end
ulang_kali { puts "block dipanggil" }

yield mengeksekusi block dua kali sehingga block dipanggil tercetak dua kali. Block juga bisa menerima argumen: yield(3) akan mengoper 3 ke parameter block seperti { |n| ... }. Pola ini menjadi dasar iterator yang akan kalian pakai terus-menerus.

#Proc dan Lambda

#Perbedaan Utama

Proc dan Lambda keduanya merepresentasikan block sebagai objek, tetapi perilakunya berbeda dalam dua hal penting: cara menangani return dan cara menangani jumlah argumen. Lambda bersifat ketat seperti method biasa, sementara Proc longgar. Lihat perbedaan return:

return dalam Proc dan Lambda

def coba_proc
  p = proc { return "return dari proc" }
  p.call
  "tidak tercapai"
end
puts coba_proc
 
def coba_lambda
  l = -> { return "return dari lambda" }
  l.call
  "setelah lambda"
end
puts coba_lambda

coba_proc menampilkan return dari proc karena return di dalam Proc keluar dari method pembungkusnya. Sebaliknya coba_lambda menampilkan setelah lambda — return di Lambda hanya keluar dari Lambda itu sendiri. p.call mengeksekusi Proc, sementara l.call mengeksekusi Lambda.

#Parameter Blok it dan _1

Sejak Ruby 3.4, block bisa memakai parameter implisit bernama it, menggantikan _1 (numbered parameter dari Ruby 2.7):

Parameter blok it dan _1

puts [1, 2, 3].map { _1 * 2 }
puts [1, 2, 3].map { it * 2 }
puts [1, 2, 3].map { |n| n * 2 }

Ketiga baris menghasilkan [2, 4, 6]. it hanya tersedia bila block tidak mendeklarasikan parameter eksplisit. map { it * 2 } lebih mudah dibaca daripada _1, dan gaya ini menjadi rekomendasi untuk kode Ruby 4.0.

#Enumerable: map, select, dan reduce

#Tiga Transformasi Inti

Modul Enumerable memberi array dan hash kekuatan transformasi data. map mengubah setiap elemen, select menyaring berdasarkan kondisi, dan reduce mengakumulasi nilai. Ketiganya mengembalikan array baru tanpa mengubah data asli:

Enumerable chaining

angka = [1, 2, 3, 4, 5, 6]
hasil = angka.select { |n| n.even? }
             .map { |n| n * 10 }
puts hasil.inspect

Block di atas menyaring angka genap, lalu mengalikan sepuluh, menghasilkan [20, 40, 60]. reduce misalnya angka.reduce(0) { |jumlah, n| jumlah + n } menjumlahkan seluruh elemen — padanan angka.sum. Kekuatan chaining terlihat saat operasi dirangkai satu sama lain.

#Chaining Method

Karena setiap transformasi mengembalikan koleksi baru, kalian bisa merangkainya tanpa henti. Ini gaya yang sangat Rails-friendly: ambil data, saring, ubah, lalu akumulasi dalam satu rangkaian. each_with_index memberi nomor urut saat iterasi. Detail lebih lanjut tentang Enumerator dan lazy evaluation akan dibahas di episode 10.

#Penutup

Episode 5 membuka kekuatan ekspresif Ruby: method dengan return implisit, parameter default, keyword arguments, dan splat, block dengan yield, perbedaan Proc dan Lambda, parameter blok it sejak Ruby 3.4, serta Enumerable dengan map, select, dan reduce yang bisa dirantai.

Inti yang harus dibawa pulang:

• Nilai ekspresi terakhir otomatis menjadi return value method.
• *args menangkap argumen posisional, **kwargs menangkap keyword arguments.
• yield mengeksekusi block; &block menangkapnya sebagai objek.
• return di Proc keluar dari method pembungkus; di Lambda hanya keluar dari Lambda.
• it adalah parameter blok implisit sejak Ruby 3.4, pengganti _1.
• map, select, dan reduce mengembalikan data baru dan bisa dirantai.

Di episode 6 selanjutnya kita akan membahas OOP: class, object, dan module — initialize, method instance dan class method, attr_accessor, pewarisan, modul dengan include, extend, dan prepend, modul bawaan Comparable dan Enumerable, serta visibility public, protected, dan private. Inilah inti paradigma Ruby.