Quais controles de fluxo o Ruby oferece?

Question

Accepted Answer

Ruby oferece controles de fluxo padrão (`if`, `case`, `while`) mas com características distintivas e expressivas: **formas modificadoras** (`do_x if condition`), `unless`, o poderoso `case/when`, e uma preferência por **iteração via blocos** em vez de laços tradicionais. O controle de fluxo em Ruby lê naturalmente.

## Condicionais (if, unless, forma modificadora)

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

A **forma modificadora** do Ruby (`puts "x" if condition`) coloca a condição no final para one-liners concisos e legíveis. **`unless`** (= "se não") lê mais naturalmente que uma negação. E `if` é uma **expressão** que retorna um valor.

## case/when — poderosa correspondência de padrões

```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`** do Ruby é poderoso — ele corresponde valores, ranges, tipos e (em Ruby 3) padrões estruturais, usando `===` sob o capô. Muito mais flexível que um switch básico.

## Laços — mas iteração é preferida

```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 tem `while`/`until`, mas Ruby idiomático **prefere iteração com blocos** (`each`, `times`, `map`) em vez de laços explícitos — mais expressivo e Ruby-like.

## Por que isso importa

Compreender o controle de fluxo do Ruby é conhecimento fundamental do dia a dia, e várias características distintivas refletem a filosofia expressiva e legível do Ruby.

A **forma modificadora** (`do_x if condition`) e **`unless`** (= "se não") permitem escrever condicionais concisos e semelhantes ao inglês que são Ruby idiomático e aparecem constantemente.

O fato de **`if` ser uma expressão** (retornando um valor) permite atribuições elegantes.

`case/when`** do Ruby é notavelmente poderoso — correspondendo valores, ranges, tipos e (em Ruby 3) padrões estruturais via `===` — tornando-o muito mais flexível que um switch básico e útil para ramificação multi-vias limpa.

Crucialmente, Ruby idiomático **prefere iteração com blocos** (`each`, `times`, `map`, `upto`) em vez de laços tradicionais `for`/`while` — este é um ponto estilístico definidor: desenvolvedores Ruby iteram coleções e ranges com métodos baseados em blocos em vez de laços explícitos, o que é mais expressivo e Ruby-like.

Compreender esses construtos e idiomas — a forma modificadora e `unless` para condicionais legíveis, o poderoso `case/when`, e especialmente a **preferência por iteração baseada em blocos em vez de laços explícitos** — é importante para escrever e ler Ruby idiomático.

Já que controle de fluxo aparece em todo programa, e já que as formas expressivas do Ruby (modificadores, `unless`, case poderoso, iteração em blocos) incorporam sua filosofia focada em legibilidade, dominá-las é conhecimento essencial e fundamental para escrever Ruby natural e idiomático em vez de traduzir padrões pesados em laços de outras linguagens.