Hoe werken variabelen en basistypen in Ruby?

Question

Accepted Answer

Ruby is **dynamisch getypt** — variabelen declareren geen type en kunnen elke waarde bevatten. Ruby heeft verschillende basistypen (allemaal objecten) en gebruikt **naamconventies** (sigils) om variabele scope aan te geven.

## Variabelen en dynamisch typen

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

## De basistypen (allemaal objecten)

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

## Naamconventies voor variabelen geven scope aan

```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 gebruikt **sigils** (voorvoegsels) om variabele scope aan te duiden: normale namen zijn lokaal, `@` voor instance-variabelen, `@@` voor klasvariabelen, `$` voor globals (niet aanbevolen), en hoofdletters voor constanten. Dit is kenmerkend — het voorvoegsel vertelt je de scope in één oogopslag.

## Truthiness (een Ruby-bijzonderheid)

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

**Alleen `false` en `nil` zijn falsy** in Ruby — `0`, `""` en `[]` zijn allemaal truthy (in tegenstelling tot veel andere talen waar 0/leeg falsy zijn). Een veel voorkomende valkuil.

## Waarom het belangrijk is

Het begrijpen van Rubys variabelen en basistypen is fundamentele dagelijkse kennis.

Ruby is dynamisch getypt (variabelen bevatten elke waarde, geen typedeklaraties), en een kenmerkend kenmerk is het gebruik van **naamconventies (sigils) om variabele scope aan te geven** — `@` voor instance-variabelen, `@@` voor klasvariabelen, `$` voor globals, hoofdletters voor constanten — dus het voorvoegsel van de variabele vertelt je de scope in één oogopslag, wat belangrijk is voor het correct lezen en schrijven van Ruby (vooral `@instance`-variabelen, die constant in klassen gebruikt worden).

Het kennen van de basistypen (die allemaal objecten zijn in Rubys zuivere object-georiënteerde model) — inclusief het kenmerkende **Symbol**-type — is noodzakelijk voor het werken met gegevens.

Een bijzonder belangrijk te begrijpen bijzonderheid is Rubys **truthiness**: **alleen `false` en `nil` zijn falsy**, terwijl alles anders (inclusief `0`, `""` en `[]`) truthy is — dit verschilt van veel andere talen (waar 0 of lege waarden falsy zijn) en is een veelvoorkomende bron van bugs voor ontwikkelaars uit andere talen.

Het begrijpen van dynamisch typen, de scope-aanduiding naamconventies, de basistypen, en vooral de false-en-nil-alleen truthiness-regel is fundamenteel voor het schrijven van correct Ruby en het vermijden van veel voorkomende valkuilen, wat het essentieel en must-know-kennis maakt voor de taal.