Qual è la differenza tra stringhe e simboli?

Question

Accepted Answer

**Le stringhe** sono sequenze mutabili di caratteri; **i simboli** (`:name`) sono identificatori immutabili e **internati** — lo stesso simbolo è esattamente lo stesso oggetto in memoria ovunque. I simboli sono usati come identificatori leggeri ed efficienti (specialmente come chiavi di hash), mentre le stringhe contengono dati di testo vero.

## Il differenza fondamentale: identità e mutabilità

```ruby
# strings — each is a NEW object (even with the same content)
"hello".object_id == "hello".object_id    # false — two different objects
"hello" << " world"                        # mutable — can be modified in place

# symbols — the SAME symbol is always the SAME object (interned)
:hello.object_id == :hello.object_id       # true — identical object every time
:hello.frozen?                              # true — symbols are immutable
```

Ogni letterale stringa crea un nuovo oggetto, ma un simbolo è **internato** — `:hello` è sempre esattamente lo stesso oggetto in memoria, non importa quante volte appare. I simboli sono anche immutabili.

## Vantaggi di memoria e prestazioni dei simboli

```text
Strings: each "name" allocates a new object → more memory, slower comparison (char by char)
Symbols: :name is ONE shared object → memory-efficient, fast comparison (by identity)
→ Symbols are ideal as identifiers used repeatedly (hash keys, method names, options).
```

## Quando usare quale

```ruby
# SYMBOLS — for identifiers: hash keys, method names, options, fixed labels
user = { name: "Ann", role: :admin }       # symbol keys (the idiom)
send(:upcase)                               # method name as a symbol
status = :active                            # a fixed label/state

# STRINGS — for actual text DATA that you display, manipulate, or that varies
name = "Ann Smith"                          # real text content
message = "Hello, #{name}"                  # building/interpolating text
user_input = gets.chomp                     # data from outside
```

Usa **simboli per identificatori** (chiavi di hash, nomi di opzioni, stati, nomi di metodi — etichette fisse e ripetute) e **stringhe per dati di testo vero** (contenuto che visualizzi, manipoli o che proviene dagli utenti).

## Conversione tra loro

```ruby
"hello".to_sym    # :hello
:hello.to_s        # "hello"
```

## Perché è importante

Comprendere la distinzione tra stringhe e simboli è importante e è una conoscenza specificamente di Ruby, poiché i simboli sono una caratteristica che molti altri linguaggi non hanno, e usarli in modo appropriato è Ruby idiomatico.

La differenza chiave è che **i simboli sono internati e immutabili** (`:name` è sempre lo stesso singolo oggetto in memoria, immutabile), mentre **le stringhe sono mutabili e ogni letterale è un nuovo oggetto**.

Questo dà ai simboli **vantaggi di memoria e prestazioni** come identificatori: sono allocati una volta e condivisi (efficienti in memoria quando usati ripetutamente), e confrontati per identità (veloce) piuttosto che carattere per carattere.

La guida pratica — **usa simboli per identificatori** (chiavi di hash, nomi di metodi, etichette di opzioni, stati fissi — cose usate ripetutamente come etichette) e **stringhe per dati di testo vero** (contenuto che visualizzi, manipoli o ricevi dagli utenti) — è importante Ruby idiomatico che influisce sia sulle prestazioni che sulla chiarezza.

Le chiavi di hash con simboli (`{ name: "Ann" }`) sono la convenzione in Ruby e Rails, e usare simboli per identificatori fissi piuttosto che stringhe è efficiente e convenzionale.

Capire quando usare ciascuno, l'internamento/immutabilità dei simboli e la loro efficienza come identificatori è conoscenza Ruby fondamentale e frequentemente applicata — è un punto di confusione comune per i principianti (perché avere entrambi?), e comprendere la distinzione (simboli come identificatori efficienti internati, stringhe come dati di testo mutabili) è essenziale per scrivere Ruby idiomatico ed efficiente ed è un argomento frequente nei colloqui che riflette la comprensione di questa caratteristica distintiva di Ruby.