Apakah kawalan aliran yang ditawarkan Ruby?

Question

Accepted Answer

Ruby menawarkan kawalan aliran standard (`if`, `case`, `while`) tetapi dengan ciri tersendiri dan ekspresif: **bentuk pengubah suai** (`do_x if condition`), `unless`, `case/when` yang berkuasa, dan keutamaan untuk **lelaran melalui blok** berbanding gelung tradisional. Kawalan aliran dalam Ruby dibaca secara semula jadi.

## Bersyarat (if, unless, bentuk pengubah suai)

```ruby
if age >= 18
  puts "adult"
elsif age >= 13
  puts "teen"
else
  puts "child"
end

# MODIFIER form — condition at the END (reads like English, idiomatic for short cases)
puts "adult" if age >= 18
puts "minor" unless age >= 18      # `unless` = if not (more readable than `if !`)

# everything is an expression — if returns a value
grade = if score >= 90 then "A" else "B" end
```

**Bentuk pengubah suai** Ruby (`puts "x" if condition`) meletakkan syarat di hujung untuk satu-baris yang ringkas dan mudah dibaca. **`unless`** (= "if not") dibaca lebih semula jadi daripada penafian. Dan `if` adalah **ungkapan** yang mengembalikan nilai.

## case/when — padanan corak yang berkuasa

```ruby
case status
when :active then "running"
when :stopped, :paused then "halted"     # multiple values
when 1..10 then "small number"            # ranges
when String then "it's a string"          # types (uses ===)
else "unknown"
end

# case can also do structural pattern matching (Ruby 3)
case data
in { name: String => name, age: Integer }   # pattern matching with destructuring
  puts name
end
```

**`case/when`** Ruby adalah berkuasa — ia memadankan nilai, julat, jenis, dan (dalam Ruby 3) corak struktur, menggunakan `===` di belakang tabir. Jauh lebih fleksibel daripada switch asas.

## Gelung — tetapi lelaran lebih diutamakan

```ruby
while count < 10 do count += 1 end
until done do ... end              # until = while not

# ✅ but Ruby PREFERS iteration with blocks over explicit loops:
5.times { |i| puts i }             # instead of a for loop
[1, 2, 3].each { |n| puts n }      # iterate a collection
(1..10).each { |n| ... }           # iterate a range
1.upto(5) { |i| ... }
```

Ruby mempunyai `while`/`until`, tetapi Ruby idiomatik **mengutamakan lelaran dengan blok** (`each`, `times`, `map`) berbanding gelung eksplisit — lebih ekspresif dan bergaya Ruby.

## Mengapa ia penting

Memahami kawalan aliran Ruby adalah pengetahuan asas harian, dan beberapa ciri tersendiri mencerminkan falsafah Ruby yang ekspresif dan mudah dibaca.

**Bentuk pengubah suai** (`do_x if condition`) dan **`unless`** (= "if not") membolehkan anda menulis bersyarat yang ringkas, seperti bahasa Inggeris, yang merupakan Ruby idiomatik dan muncul secara berterusan.

Hakikat bahawa **`if` adalah ungkapan** (mengembalikan nilai) membolehkan tugasan yang elegan.

**`case/when`** Ruby amat berkuasa — memadankan nilai, julat, jenis, dan (dalam Ruby 3) corak struktur melalui `===` — menjadikannya jauh lebih fleksibel daripada switch asas dan berguna untuk percabangan berbilang-arah yang bersih.

Yang penting, Ruby idiomatik **mengutamakan lelaran dengan blok** (`each`, `times`, `map`, `upto`) berbanding gelung `for`/`while` tradisional — ini adalah titik stilistik yang mentakrifkan: pembangun Ruby melelar koleksi dan julat dengan kaedah berasaskan blok dan bukannya gelung eksplisit, yang lebih ekspresif dan bergaya Ruby.

Memahami konstruk dan idiom ini — bentuk pengubah suai dan `unless` untuk bersyarat yang mudah dibaca, `case/when` yang berkuasa, dan terutamanya **keutamaan untuk lelaran berasaskan blok berbanding gelung eksplisit** — adalah penting untuk menulis dan membaca Ruby idiomatik.

Memandangkan kawalan aliran muncul dalam setiap program, dan kerana bentuk ekspresif Ruby (pengubah suai, `unless`, case yang berkuasa, lelaran blok) menjelmakan falsafahnya yang berfokus pada kebolehbacaan, menguasainya adalah pengetahuan asas yang penting untuk menulis Ruby yang semula jadi dan idiomatik dan bukannya menterjemah corak yang banyak menggunakan gelung dari bahasa lain.