Care sunt metodele utile de String și variantele cu bang (!)?

Question

Accepted Answer

Stringurile Ruby au o mulțime bogată de metode pentru manipulare, iar multe vin în două forme: o versiune normală (returnează un **string nou**) și o versiune cu **bang (`!`)** (modifică stringul **pe loc**, mutând originalul). Înțelegerea acestei distincții este importantă pentru corectitudine și evitarea erorilor.

## Metode obișnuite de string

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

## Distinția crucială cu bang (!): mutația pe loc

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

Versionele cu **`!` (bang) mută stringul original pe loc**, în timp ce versiunile fără bang returnează un string nou și lasă originalul neschimbat. Aceasta este o distincție critică — folosirea `upcase!` când ai vrut `upcase` (sau invers) schimbă dacă originalul este modificat, ceea ce poate cauza erori subtile.

## O capcană cu bang: nil returnate când nu se face nicio schimbare

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

O capcană subtilă: metodele cu bang returnează **`nil`** dacă nu au făcut nicio schimbare — deci înlănțuirea pe valoarea lor returnată poate eșua.

## De ce conteaza

Manipularea stringurilor este omniprezentă în programare, deci cunoașterea metodelor bogate de string din Ruby este cunoștință utilă de zi cu zi — dar cel mai important punct este înțelegerea **distincției bang (`!`) versus fără bang**, care este atât o convenție de denumire Ruby cât și o sursă frecventă de erori.

Versiunea fără bang returnează un **string nou** (lăsând originalul neschimbat), în timp ce **versiunea cu bang mută originalul pe loc** — și confundarea lor schimbă dacă obiectul original este modificat, ceea ce cauzeaza erori subtile și greu de depanat (de exemplu, așteptând originalul neschimbat dar folosind `upcase!` îl mută, sau așteptând mutație dar folosind `upcase` lasă originalul neatins).

De vreme ce stringurile Ruby sunt mutabile și multe metode au ambele forme, înțelegerea acestei distincții este importantă pentru corectitudine — știind că `!` de obicei înseamnă "modifică pe loc / este versiunea periculoasă" (o convenție care se extinde dincolo de stringuri la alte metode Ruby precum `map!`, `sort!`) te permite să previi și să controlezi comportamentul de mutație.

**Capcana** suplimentară că metodele cu bang returnează `nil` când nu fac nicio schimbare (ceea ce poate rupe înlănțuirea metodelor) este de asemenea valoroasă de cunoscut.

Înțelegerea metodelor utile de string din Ruby și mai ales **distinția mutație bang/non-bang** (o convenție Ruby de bază care afectează dacă originalul este modificat) este importantă pentru scrierea Ruby corect care gestionează stringurile în siguranță — este o sursă frecventă de erori de mutație, și convenția `!` este un idiom Ruby fundamental care reflectă înțelegerea semanticii pe loc versus noi obiecte, făcând-o cunoștință practic relevantă pentru munca constantă cu stringuri în Ruby și un subiect comun despre o convenție distinctivă și predispusă la erori din Ruby.