Hur fungerar variabler och grundläggande typer i Ruby?

Question

Accepted Answer

Ruby är **dynamiskt typat** — variabler deklarerar inte en typ och kan innehålla vilket värde som helst. Ruby har flera grundläggande typer (allt är objekt) och använder **namngivningskonventioner** (sigiler) för att indikera variabelns omfattning.

## Variabler och dynamisk typning

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

## De grundläggande typerna (allt är objekt)

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

## Namngivningskonventioner för variabler indikerar omfattning

```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 använder **sigiler** (prefix) för att beteckna variabelns omfattning: vanliga namn är lokala, `@` för instansvariabler, `@@` för klassvariabler, `$` för globala variabler (avrådes), och versaler för konstanter. Detta är särskilt — prefixet säger dig omfattningen vid en blick.

## Sanningsvärde (en Ruby-egenhet)

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

**Endast `false` och `nil` är falska** i Ruby — `0`, `""` och `[]` är alla sanningar (till skillnad från många andra språk där 0/tomma värden är falska). En vanlig fallgrop.

## Varför det spelar roll

Att förstå Rubys variabler och grundläggande typer är fundamental kuskap för varje dag.

Ruby är dynamiskt typat (variabler kan innehålla vilket värde som helst, ingen typdeklaration), och en särskilt utmärkande egenskap är dess användning av **namngivningskonventioner (sigiler) för att indikera variabelns omfattning** — `@` för instansvariabler, `@@` för klassvariabler, `$` för globala variabler, versaler för konstanter — så variabelns prefix säger dig dess omfattning vid en blick, vilket är viktigt för att läsa och skriva Ruby korrekt (särskilt `@instans`-variabler, som används konstant i klasser).

Att känna till de grundläggande typerna (som alla är objekt i Rubys helt objektorienterade modell) — inklusive den särskilda **Symbol**-typen — är nödvändigt för att arbeta med data.

En särskilt viktig egenhet att förstå är Rubys **sanningsvärde**: **endast `false` och `nil` är falska**, medan allt annat (inklusive `0`, `""` och `[]`) är sant — detta skiljer sig från många andra språk (där 0 eller tomma värden är falska) och är en vanlig källa till buggar för utvecklare från andra språk.

Att förstå dynamisk typning, de omfattningsindikerade namngivningskonventionerna, de grundläggande typerna, och särskilt regeln om att endast false-och-nil är falska, är grundläggande för att skriva korrekt Ruby och undvika vanliga fallgropar, vilket gör det till väsentlig, måste-kunna-kunskap för språket.