Wie funktionieren Variablen und grundlegende Typen in Ruby?

Question

Accepted Answer

Ruby ist **dynamisch typisiert** — Variablen deklarieren keinen Typ und können jeden Wert halten. Ruby hat mehrere grundlegende Typen (alle sind Objekte) und verwendet **Benennungskonventionen** (Sigils) zur Angabe des Variablenbereichs.

## Variablen und dynamische Typisierung

```ruby
count = 42           # no type declaration — inferred
name = "Ann"
count = "now a string"   # dynamically typed — can change type
```

## Die grundlegenden Typen (alle sind Objekte)

```ruby
42              # Integer
3.14            # Float
"hello"         # String
:symbol         # Symbol (an immutable, interned identifier)
true / false    # Boolean (TrueClass / FalseClass)
nil             # NilClass — "nothing" (Ruby's null)
[1, 2, 3]       # Array
{ a: 1 }        # Hash (key-value)
1..10           # Range
```

## Benennungskonventionen für Variablen zeigen den Bereich an

```ruby
name        = "local"      # local variable (lowercase)
@instance   = "instance"   # @ → INSTANCE variable (per object)
@@class_var = "class"      # @@ → CLASS variable (shared across instances)
$global     = "global"     # $ → global variable (avoid)
CONSTANT    = "constant"   # Uppercase start → CONSTANT (convention; can change with warning)
```

Ruby verwendet **Sigils** (Präfixe), um den Variablenbereich zu kennzeichnen: einfache Namen sind lokal, `@` für Instanzvariablen, `@@` für Klassenvariablen, `$` für globale Variablen (nicht empfohlen) und Großbuchstaben für Konstanten. Dies ist charakteristisch — das Präfix zeigt dir den Bereich auf einen Blick.

## Wahrheitswerte (eine Ruby-Besonderheit)

```ruby
# in Ruby, ONLY false and nil are falsy — EVERYTHING else is truthy
puts "truthy" if 0        # prints — 0 is TRUTHY in Ruby! (unlike many languages)
puts "truthy" if ""        # prints — empty string is truthy too
puts "falsy" unless nil    # nil is falsy
```

**Nur `false` und `nil` sind falsy** in Ruby — `0`, `""` und `[]` sind alle truthy (anders als in vielen Sprachen, in denen 0/leere Werte falsy sind). Eine häufige Fallstricke.

## Warum es wichtig ist

Das Verständnis von Rubys Variablen und grundlegenden Typen ist fundamentales alltägliches Wissen.

Ruby ist dynamisch typisiert (Variablen können jeden Wert halten, keine Typdeklarationen), und ein charakteristisches Merkmal ist die Verwendung von **Benennungskonventionen (Sigils) zur Angabe des Variablenbereichs** — `@` für Instanzvariablen, `@@` für Klassenvariablen, `$` für globale Variablen, Großbuchstaben für Konstanten — sodass das Präfix der Variablen dir den Bereich auf einen Blick zeigt, was wichtig ist, um Ruby korrekt zu lesen und zu schreiben (besonders `@instance`-Variablen, die ständig in Klassen verwendet werden).

Die grundlegenden Typen zu kennen (die alle Objekte in Rubys reines objektorientierten Modell sind) — einschließlich des charakteristischen **Symbol**-Typs — ist notwendig, um mit Daten zu arbeiten.

Eine besonders wichtige Besonderheit ist Rubys **Wahrheitswerte**: **nur `false` und `nil` sind falsy**, während alles andere (einschließlich `0`, `""` und `[]`) truthy ist — das unterscheidet sich von vielen Sprachen (wo 0 oder leere Werte falsy sind) und ist eine häufige Fehlerquelle für Entwickler, die von anderen Sprachen kommen.

Das Verständnis von dynamischer Typisierung, den bereichsanzeigenden Benennungskonventionen, den grundlegenden Typen und besonders der Regel, dass nur false und nil falsy sind, ist grundlegend für das Schreiben von korrektem Ruby und das Vermeiden häufiger Fallstricke, was es zu essenziellem, notwendigem Wissen für die Sprache macht.