Hvordan fungerer variabler og grundlæggende typer i Ruby?

Question

Accepted Answer

Ruby er **dynamisk typet** — variabler deklarerer ikke en type og kan holde enhver værdi. Ruby har flere grundlæggende typer (alle objekter), og bruger **navngivningskonventioner** (sigler) til at angive variabelomfang.

## Variabler og dynamisk typning

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

## De grundlæggende typer (alle er objekter)

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

## Navngivningskonventioner for variabler angiver omfang

```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 bruger **sigler** (præfikser) til at betegne variabelomfang: enkle navne er lokale, `@` for instansvariabler, `@@` for klassevaribler, `$` for globale (frarådet), og store bogstaver for konstanter. Dette er karakteristisk — præfikset fortæller dig omfanget med det samme.

## Sandhedsværdi (en Ruby særkendetegn)

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

**Kun `false` og `nil` er falsy** i Ruby — `0`, `""` og `[]` er alle truthy (i modsætning til mange andre sprog, hvor 0/tomme værdier er falsy). En almindelig fælde.

## Hvorfor det betyder noget

At forstå Rubys variabler og grundlæggende typer er fundamental daglig viden.

Ruby er dynamisk typet (variabler holder enhver værdi, ingen typedeklarationer), og et karakteristisk træk er brugen af **navngivningskonventioner (sigler) til at angive variabelomfang** — `@` for instansvariabler, `@@` for klassevaribler, `$` for globale, store bogstaver for konstanter — så variablens præfiks fortæller dig dets omfang på et blik, hvilket er vigtigt for at læse og skrive Ruby korrekt (især `@instance`-variabler, som bruges konstant i klasser).

At kende de grundlæggende typer (som alle er objekter i Rubys rene objektorienterede model) — herunder den karakteristiske **Symbol**-type — er nødvendigt for at arbejde med data.

En særlig vigtig særkendetegn at forstå er Rubys **sandhedsværdi**: **kun `false` og `nil` er falsy**, mens alt andet (herunder `0`, `""` og `[]`) er truthy — dette adskiller sig fra mange sprog (hvor 0 eller tomme værdier er falsy) og er en almindelig kilde til fejl for udviklere fra andre sprog.

At forstå dynamisk typning, omfang-angivende navngivningskonventioner, de grundlæggende typer, og især false-og-nil-kun-sandhedsværdi-reglen er grundlæggende for at skrive korrekt Ruby og undgå almindelige faldgruber, hvilket gør det til essentiel, must-know-viden for sproget.