Wie definierst du Methoden mit Argumenten?

Question

Accepted Answer

Ruby-**Methoden** werden mit `def...end` definiert. Ruby hat flexible, ausdrucksstarke Argumentverwaltung — Standardwerte, Keyword-Argumente, Splat (`*`) für variable Argumente und Blöcke — plus die Konvention, dass der **letzte Ausdruck der implizite Rückgabewert** ist.

## Basis-Methoden und implizite Rückgabe

```ruby
def add(a, b)
  a + b          # NO `return` needed — the last expression is returned implicitly
end
add(2, 3)         # 5

def greet(name)
  "Hello, #{name}"   # implicitly returned
end
```

Ruby-Methoden **geben den zuletzt ausgewerteten Ausdruck automatisch zurück** — du schreibst selten `return` (es wird nur für frühe Rückgaben verwendet). Das ist idiomatisch.

## Standard- und Keyword-Argumente

```ruby
# default arguments
def greet(name, greeting = "Hello")
  "#{greeting}, #{name}"
end
greet("Ann")              # "Hello, Ann"
greet("Ann", "Hi")        # "Hi, Ann"

# KEYWORD arguments (clearer, order-independent) — common in modern Ruby
def create_user(name:, age: 0, role: :user)
  # name is required (no default); age/role optional
end
create_user(name: "Ann", role: :admin)   # pass by keyword — readable
```

**Keyword-Argumente** (`name:`) sind idiomatisches modernes Ruby — sie machen Aufrufe selbstdokumentierend und unabhängig von der Reihenfolge.

## Splat-Argumente (variable Anzahl)

```ruby
def sum(*numbers)        # * collects extra positional args into an array
  numbers.sum
end
sum(1, 2, 3, 4)          # 10

def config(**options)    # ** collects keyword args into a hash
  options[:timeout]
end
config(timeout: 30, retries: 3)
```

`*args` sammelt variable Positionsargumente in ein Array; `**options` sammelt Keyword-Argumente in ein Hash.

## Methoden endend mit ? und !

```ruby
def valid?(x)            # ? convention → returns a boolean (predicate method)
  x > 0
end
def process!(data)       # ! convention → modifies in place / is "dangerous"
  data.map!(&:upcase)
end
```

Namenskonventionen: Methoden endend mit **`?`** geben Boolesche Werte zurück (Prädikate), und **`!`** zeigt eine destruktive/in-place oder "gefährliche" Version an.

## Warum es wichtig ist

Methoden sind die Bausteine des Verhaltens in Ruby, und das Verständnis von Rubys flexibler, ausdrucksstarker Argumentverwaltung und Konventionen ist wichtiges tägliches Wissen.

Mehrere Aspekte sind deutlich Ruby-spezifisch und wissenswert: die **implizite Rückgabe** (Methoden geben den zuletzt ausgewerteten Ausdruck zurück, also wird `return` selten geschrieben — idiomatisches Ruby verlässt sich darauf), **Keyword-Argumente** (`name:` — die moderne, idiomatische Art, klare, selbstdokumentierende, unabhängig von der Reihenfolge funktionierende Methodenaufrufe zu schreiben), und **Splat-Argumente** (`*args`/`**options` für variable Anzahl von Argumenten).

Gleich wichtig sind die **Namenskonventionen** — Methoden endend mit **`?`** sind Prädikate, die Boolesche Werte zurückgeben (`valid?`, `empty?`), und Methoden endend mit **`!`** sind destruktive/in-place oder "gefährliche" Versionen (`map!`, `sort!`) — die in Ruby und Rails allgegenwärtig sind und das Verhalten einer Methode auf einen Blick mitteilen (zu wissen, dass `!` typischerweise "modifiziert an Ort und Stelle" bedeutet, ist wichtig, um unbeabsichtigte Mutationen zu vermeiden).

Das Verständnis, wie man Methoden mit Rubys flexiblen Argumenten (Standard, Keywords, Splats) definiert, das idiom der impliziten Rückgabe und die `?`/`!`-Namenskonventionen sind grundlegend für das Schreiben und Lesen idiomatischen Rubys — diese Merkmale und Konventionen erscheinen ständig, und sie zu verstehen (besonders Keyword-Argumente für saubere APIs und die `?`/`!`-Konventionen zum Verständnis des Methodenverhaltens) ist essentiell, häufig angewendetes Wissen für effektive Ruby-Entwicklung.