Quali sono i metodi String utili e le varianti con bang (!)?

Question

Accepted Answer

Le stringhe Ruby hanno un ricco insieme di metodi per la manipolazione, e molti vengono in due forme: una versione normale (restituisce una **nuova** stringa) e una versione **bang (`!`)** (modifica la stringa **in place**, mutando l'originale). Comprendere questa distinzione è importante per la correttezza e per evitare bug.

## Metodi string comuni

```ruby
"hello".upcase           # "HELLO"
"HELLO".downcase          # "hello"
"  hi  ".strip             # "hi" — remove surrounding whitespace
"hello".reverse           # "olleh"
"hello".length            # 5
"hello world".split(" ")  # ["hello", "world"]
["a", "b"].join("-")       # "a-b"
"hello".sub("l", "L")      # "heLlo" — replace FIRST
"hello".gsub("l", "L")     # "heLLo" — replace ALL (global)
"hello".include?("ell")    # true
"hello".start_with?("he")  # true
"hello".chars             # ["h", "e", "l", "l", "o"]
"42".to_i; "3.14".to_f      # convert to number
"Hi #{name}"               # interpolation
```

## La distinzione cruciale bang (!): mutazione in place

```ruby
str = "hello"

# normal version — returns a NEW string, original UNCHANGED
upper = str.upcase        # upper = "HELLO", but str is STILL "hello"
puts str                  # "hello" — unchanged

# BANG version — modifies the original IN PLACE (mutates it)
str.upcase!               # str is NOW "HELLO" — the original changed!
puts str                  # "HELLO"
```

Le versioni **`!` (bang) mutano la stringa originale in place**, mentre le versioni non-bang restituiscono una nuova stringa e lasciano l'originale invariata. Questa è una distinzione critica — usare `upcase!` quando intendevi `upcase` (o viceversa) cambia se l'originale viene modificato, il che può causare bug sottili.

## Una trappola bang: ritorno nil quando non c'è cambio

```ruby
"hello".upcase!     # "HELLO"
"HELLO".upcase!     # nil! — bang methods return nil if NOTHING changed
# → don't chain off a bang method's return value carelessly
str.strip!&.upcase  # be careful — strip! returns nil if there was nothing to strip
```

Una trappola sottile: i metodi bang restituiscono **`nil`** se non hanno effettuato alcun cambio — quindi concatenare il loro valore di ritorno può interrompere.

## Perché è importante

La manipolazione delle stringhe è pervasiva nella programmazione, quindi conoscere i ricchi metodi string di Ruby è una conoscenza utile quotidiana — ma il punto più importante è comprendere la **distinzione bang (`!`) vs non-bang**, che è sia una convenzione di naming Ruby sia una frequente fonte di bug.

La versione non-bang restituisce una **nuova** stringa (lasciando l'originale invariata), mentre la **versione bang muta l'originale in place** — e confonderle cambia se l'oggetto originale viene modificato, il che causa bug sottili e difficili da debuggare (es. aspettandosi l'originale invariato ma usando `upcase!` lo muta, o aspettandosi la mutazione ma usando `upcase` lascia l'originale intatto).

Poiché le stringhe Ruby sono mutabili e molti metodi hanno entrambe le forme, comprendere questa distinzione è importante per la correttezza — sapendo che `!` tipicamente significa "modifica in place / è la versione pericolosa" (una convenzione che si estende oltre le stringhe ad altri metodi Ruby come `map!`, `sort!`) ti permette di prevedere e controllare il comportamento di mutazione.

La **trappola** aggiuntiva che i metodi bang restituiscono `nil` quando non effettuano alcun cambio (il che può interrompere il concatenamento di metodi) è anche utile da conoscere.

Comprendere i metodi string utili di Ruby e soprattutto la **distinzione bang/non-bang di mutazione** (una convenzione Ruby fondamentale che influenza se l'originale viene modificato) è importante per scrivere Ruby corretto che gestisce le stringhe in sicurezza — è una frequente fonte di bug di mutazione, e la convenzione `!` è un idioma Ruby fondamentale che riflette la comprensione della semantica in-place vs. nuovo-oggetto, rendendola una conoscenza praticamente rilevante per il costante lavoro con stringhe in Ruby e un argomento comune su una convenzione Ruby distintiva e soggetta a bug.