Come funzionano le variabili e i tipi di base in Ruby?

Question

Accepted Answer

Ruby è **dinamicamente tipizzato** — le variabili non dichiarano un tipo e possono contenere qualsiasi valore. Ruby ha diversi tipi di base (tutti oggetti) e usa **convenzioni di naming** (sigili) per indicare lo scope delle variabili.

## Variabili e tipizzazione dinamica

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

## I tipi di base (tutti sono oggetti)

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

## Le convenzioni di naming delle variabili indicano lo scope

```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 usa **sigili** (prefissi) per denotare lo scope delle variabili: i nomi semplici sono locali, `@` per variabili di istanza, `@@` per variabili di classe, `$` per globali (sconsigliato), e maiuscole per costanti. Questo è distintivo — il prefisso ti dice lo scope a colpo d'occhio.

## Truthiness (una peculiarità di Ruby)

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

**Solo `false` e `nil` sono falsy** in Ruby — `0`, `""`, e `[]` sono tutti truthy (a differenza di molti altri linguaggi dove 0/valori vuoti sono falsy). Un errore comune.

## Perché è importante

Comprendere le variabili e i tipi di base di Ruby è una conoscenza fondamentale e quotidiana.

Ruby è dinamicamente tipizzato (le variabili contengono qualsiasi valore, senza dichiarazioni di tipo), e una caratteristica distintiva è l'uso di **convenzioni di naming (sigili) per indicare lo scope delle variabili** — `@` per variabili di istanza, `@@` per variabili di classe, `$` per globali, maiuscole per costanti — quindi il prefisso della variabile ti dice il suo scope a colpo d'occhio, il che è importante per leggere e scrivere correttamente Ruby (soprattutto variabili `@instance`, usate costantemente nelle classi).

Conoscere i tipi di base (che sono tutti oggetti nel modello puramente object-oriented di Ruby) — incluso il tipo distintivo **Symbol** — è necessario per lavorare con i dati.

Una peculiarità particolarmente importante da comprendere è la **truthiness di Ruby**: **solo `false` e `nil` sono falsy**, mentre tutto il resto (incluso `0`, `""`, e `[]`) è truthy — questo differisce da molti linguaggi (dove 0 o valori vuoti sono falsy) ed è una fonte comune di bug per sviluppatori provenienti da altri linguaggi.

Comprendere la tipizzazione dinamica, le convenzioni di naming che indicano lo scope, i tipi di base, e soprattutto la regola della truthiness solo-false-e-nil è fondamentale per scrivere Ruby corretto ed evitare insidie comuni, rendendola una conoscenza essenziale e fondamentale del linguaggio.