Apa bedane antara blocks, procs lan lambdas?

Question

Accepted Answer

Iki telu cara Ruby nangani **potongan kode minangka data**. **Block** dilewatake menyang method (dudu obyek); **Proc** lan **lambda** yaiku obyek sing mbungkus block (callable, storable). Procs lan lambdas beda kanthi alus ing pengecekan argument lan tingkah laku `return`.

## Blocks — dilewatake menyang methods (dudu obyek)

```ruby
[1, 2, 3].each { |n| puts n }     # the { } is a block — passed to each
# a block is NOT an object; it's part of the method call, can't be stored in a variable directly
```

Block yaiku kode sing dilewatake menyang method (ing `{ }` utawa `do...end`) — iki dudu obyek mandiri sing bisa disimpen; iki terikat karo manggilan method.

## Procs lan lambdas — blocks minangka obyek storable

```ruby
# a Proc — a block turned into an object you can store and call
square = Proc.new { |x| x * x }
square.call(5)        # 25
square.(5)            # 25 (alternate call syntax)

# a lambda — also a callable object (a "stricter" Proc)
double = lambda { |x| x * 2 }
double = ->(x) { x * 2 }   # the -> "stabby lambda" syntax
double.call(5)        # 10
```

Procs lan lambdas mbungkus block dadi **obyek** sing bisa ditaleni menyang variabel, dilewatake, lan dipanggil mengko (`.call`) — migunani kanggo nyimpen tingkah laku sing bisa digunakake maneh.

## Bedane kunci: arguments lan return

```text
1. ARGUMENT CHECKING:
   lambda → STRICT: errors if wrong number of arguments (like a method)
   proc   → LENIENT: ignores extra args, fills missing with nil

2. RETURN behavior:
   lambda → `return` returns from the LAMBDA (like a normal method)
   proc   → `return` returns from the ENCLOSING METHOD (can surprise you!)
```

```ruby
def test_proc
  p = Proc.new { return 10 }
  p.call                       # returns from test_proc ENTIRELY → 10
  return 20                    # never reached!
end

def test_lambda
  l = lambda { return 10 }
  l.call                       # returns from the LAMBDA only → 10
  return 20                    # reached → test_lambda returns 20
end
```

Bedane paling penting: **lambda tumindak kaya method** (argument ketat, `return` metu mung saka lambda), dene **proc luwih lenient** (nglirwakne ketidaksesuaian argument, lan `return` metu saka method sing mbungkus — iki bisa nimbulaké tingkah laku sing ngesurprise). **Lambdas luwih disenengi** kanthi tingkah laku kaya method, bisa diturangaken.

## Apa gunane iki

Ngerti blocks, procs, lan lambdas — lan utamane bedane — yaiku pengetahuan Ruby penting sing nuduhake paham luwih jujur babagan cara Ruby nangani kode minangka data. **Blocks** paling umum (dilewatake menyang methods kanggo iterasi lan callbacks — ciri signature Ruby), dene **procs lan lambdas** nggawe blocks dadi obyek storable, bisa digunakake maneh sing bisa ditaleni menyang variabel, dilewatake, lan dipanggil mengko (migunani kanggo nyimpen tingkah laku, nulis pola functional, lan ngirim callbacks minangka nilai).

**Bedane kunci antara procs lan lambdas** alus banget nanging penting lan topik interview kerep: **pengecekan argument** (lambdas ketat kaya methods, procs lenient) lan utamane **tingkah laku `return`** (lambda `return` metu mung saka lambda, dene proc `return` metu saka *method sing mbungkus* — iki bisa nimbulaké tingkah laku ngesurprise, angel di-debug).

Ngerti bedane iki — yen **lambda tumindak kaya method** (ketat, bisa diturangaken, lokalisir return) dene **proc luwih lenient kanthi semantik return ngesurprise** — penting kanggo nggunakake iku bener lan kanggo rekomendasi umum **preferan lambdas** kanthi tingkah laku predictable, kaya method.

Sanajan blocks yaiku Ruby setiap hari lan procs/lambdas digunakake kanggo callbacks storable lan pola functional, ngerti kabeh telu (utamane bedane proc-vs-lambda return lan argument) nuduhake pengetahuan Ruby solid, mbantu ngelak gotcha proc-return, lan topik interview klasik sing mbedakake developer sing bener-bener ngerti penanganan Ruby kode minangka obyek.