Setelah memahami metode, saatnya mempelajari konsep unik dalam Ruby: Blok, Procs, dan Lambdas. Ketiganya memungkinkan Anda memperlakukan kode sebagai objek — bisa dikirim, disimpan, dan dijalankan.

1. Blok — Kode Anonim

Blok adalah sepotong kode yang tidak bernama (anonymous) yang bisa dikirim ke metode.

Blok Dasar

5.times do
  puts "Hello, Ruby!"
end
# Output: Hello, Ruby! (5 kali)

Blok dengan Parameter

[1, 2, 3].each do |angka|
  puts "Angka: #{angka}"
end
# Output:
# Angka: 1
# Angka: 2
# Angka: 3

Blok Singkat

[1, 2, 3].each { |n| puts n }

Kapan pakai do...end vs {...}?

• do...end → blok multi-line
• {...} → blok single-line

2. yield — Menjalankan Blok di Metode

Kata kunci yield menjalankan blok yang dikirim ke metode:

def sapa
  puts "Sebelum yield"
  yield
  puts "Setelah yield"
end

sapa do
  puts "  >> Blok dijalankan! <<"
end
# Output:
# Sebelum yield
#   >> Blok dijalankan! <<
# Setelah yield

yield dengan Parameter

def sapa_orang
  yield("Andika")
  yield("Rekatias")
end

sapa_orang do |nama|
  puts "Halo, #{nama}!"
end
# Output:
# Halo, Andika!
# Halo, Rekatias!

block_given? — Cek Ada Blok

def metode_dengan_blok
  if block_given?
    yield
  else
    puts "Tidak ada blok"
  end
end

metode_dengan_blok                    # Tidak ada blok
metode_dengan_blok { puts "Ada!" }   # Ada!

3. Proc — Menyimpan Blok sebagai Objek

Proc adalah objek yang berisi blok kode. Simpan dalam variabel, panggil kapan saja.

greet = Proc.new do |nama|
  puts "Halo, #{nama}!"
end

greet.call("Andika")   # Halo, Andika!
greet.call("Budi")     # Halo, Budi!

Proc dengan Lambda

greet = lambda { |nama| puts "Halo, #{nama}!" }
greet.call("Ruby")  # Halo, Ruby!

Menggunakan & untuk Mengubah Blok

def sapa(&block)
  block.call("Andika")
end

sapa { |nama| puts "Halo, #{nama}!" }  # Halo, Andika!

4. Lambda — Proc yang Lebih Ketat

Lambda mirip Proc, tapi lebih ketat dalam hal:

• Pengecekan jumlah argument
• Perilaku return dan break

Membuat Lambda

greet = lambda { |nama| puts "Halo, #{nama}" }
greet.call("Andika")  # Halo, Andika

# Syntax lebih umum
greet = -> (nama) { puts "Halo, #{nama}" }

Lambda Memeriksa Argument

greet = -> (nama) { puts "Halo, #{nama}" }

greet.call("Andika")       # OK
# greet.call()              # Error: wrong number of arguments
# greet.call("A", "B")     # Error: wrong number of arguments

Proc Tidak Memeriksa

greet = Proc.new { |nama| puts "Halo, #{nama}" }

greet.call("Andika")       # OK
greet.call()               # Halo,  (nama = nil)
greet.call("A", "B")      # Halo, A (extra arg ignored)

5. Perbedaan Proc dan Lambda

Aspek	Proc	Lambda
Cek argument	Tidak	Ya
Return	Keluar dari metode	Keluar dari lambda
Break	Keluar dari metode	Error

Contoh Perbedaan Return

def test_proc
  p = Proc.new { return "Dari Proc" }
  p.call
  "Setelah Proc"
end
puts test_proc  # Dari Proc (langsung keluar dari metode)

def test_lambda
  l = lambda { return "Dari Lambda" }
  l.call
  "Setelah Lambda"
end
puts test_lambda  # Setelah Lambda

6. Closure — Mengakses Variabel Luar

Blok, Proc, dan Lambda adalah closure — mereka bisa mengakses variabel dari scope luar:

x = 10
tambah = Proc.new { |n| n + x }

puts tambah.call(5)   # 15
x = 20
puts tambah.call(5)   25 (pakai nilai x terbaru)

7. Ringkasan

Konsep	Kegunaan	Contoh
Blok	Kode anonim	method { \|x\| ... }
yield	Jalankan blok	yield
Proc	Simpan blok sebagai objek	Proc.new { \|x\| ... }
Lambda	Proc yang lebih ketat	-> (x) { ... }
&block	Blok jadi Proc	def method(&block)
Closure	Akses variabel luar	x = 10; p = -> { x }

Penutup

Blok, Procs, dan Lambdas adalah fitur unik Ruby yang membuat kode lebih fleksibel. Pahami kapan pakai blok, Proc, atau Lambda — maka kode Anda jadi lebih clean dan maintainable.

Di artikel selanjutnya, kita akan bahas OOP dalam Ruby — class, inheritance, dan modules.

---