Vilken kontrollflöde erbjuder Ruby?

Question

Accepted Answer

Ruby erbjuder standard kontrollflöde (`if`, `case`, `while`) men med distinkta, expressiva funktioner: **modifieringsformer** (`do_x if condition`), `unless`, den kraftfulla `case/when`, och en preferens för **iteration via block** framför traditionella loopar. Kontrollflöde i Ruby läses naturligt.

## Villkor (if, unless, modifieringsform)

```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
```

Rubys **modifieringsform** (`puts "x" if condition`) placerar villkoret i slutet för koncisa, läsbara enradare. **`unless`** (= "if not") läses mer naturligt än negation. Och `if` är ett **uttryck** som returnerar ett värde.

## case/when — kraftfull mönstermatchning

```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
```

Rubys **`case/when`** är kraftfull — den matchar värden, intervall, typer, och (i Ruby 3) strukturella mönster, med `===` under huven. Långt mer flexibel än en grundläggande switch.

## Loopar — men iteration är att föredra

```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 har `while`/`until`, men idiomatisk Ruby **föredrar iteration med block** (`each`, `times`, `map`) framför explicita loopar — mer expressivt och Ruby-likt.

## Varför det spelar roll

Att förstå Rubys kontrollflöde är grundläggande varje dag kunskap, och flera distinkta funktioner återspeglar Rubys expressiva, läsbara filosofi.

**Modifieringsformen** (`do_x if condition`) och **`unless`** (= "if not") låter dig skriva koncisa, engelska-liknande villkor som är idiomatisk Ruby och förekommer konstant.

Det faktum att **`if` är ett uttryck** (returnerar ett värde) möjliggör eleganta tilldelningar.

Rubys **`case/when`** är särskilt kraftfull — den matchar värden, intervall, typer, och (i Ruby 3) strukturella mönster via `===` — vilket gör den långt mer flexibel än en grundläggande switch och användbar för ren flervägsgrenning.

Krucial är att idiomatisk Ruby **föredrar iteration med block** (`each`, `times`, `map`, `upto`) framför traditionella `for`/`while` loopar — detta är en definerande stilistisk poäng: Ruby-utvecklare itererar samlingar och intervall med blockbaserade metoder snarare än explicita loopar, vilket är mer expressivt och Ruby-likt.

Att förstå dessa konstruktioner och idiom — modifieringsformen och `unless` för läsbara villkor, den kraftfulla `case/when`, och särskilt **preferensen för blockbaserad iteration framför explicita loopar** — är viktigt för att skriva och läsa idiomatisk Ruby.

Eftersom kontrollflöde förekommer i alla program, och eftersom Rubys expressiva former (modifieringar, `unless`, kraftfull case, blockiteration) förkroppsligar dess läsbarhets-fokuserad filosofi, är det att bemästra dem väsentlig, grundläggande kunskap för att skriva naturlig, idiomatisk Ruby snarare än att översätta loop-tunga mönster från andra språk.