Koja su korisna String metoda i varijante sa udarcem (!)?

Question

Accepted Answer

Ruby stringovi imaju bogat skup metoda za manipulaciju, a mnoge dolaze u dva oblika: normalnu verziju (vraća **novi** string) i verziju sa **udarcem (`!`)** (mijenja string **na mjestu**, mutirajući original). Razumijevanje ove razlike je važno za ispravnost i izbjegavanje grešaka.

## Česte string metode

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

## Kritična razlika sa udarcem (!): mutacija na mjestu

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

**Verzije sa `!` (udarcem) mutiraju originalni string na mjestu**, dok verzije bez udarca vraćaju novi string i ostavljaju original nepromijenjen. Ovo je kritična razlika — korištenje `upcase!` kad ste mislili `upcase` (ili obrnuto) mijenja da li je original promijenjen, što može uzrokovati suptilne greške.

## Zamka sa udarcem: nil vraćanje kada nema promjene

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

Suptilna zamka: metode sa udarcem vraćaju **`nil`** ako nisu napravile promjenu — pa lančanje poziva na njihovu povratnu vrijednost može biti problematično.

## Zašto je to važno

Manipulacija stringovima je sveprisutna u programiranju, pa je poznavanje Ruby-jevih bogatih string metoda korisno svakodnevno znanje — ali najvažnija točka je razumijevanje **razlike između udarca (`!`) i bez udarca**, što je i Ruby konvencija za imenovanje i česta izvor grešaka.

Verzija bez udarca vraća **novi** string (ostavljajući original nepromijenjen), dok **verzija sa udarcem mutira original na mjestu** — i miješanje tih verzija mijenja da li je originalni objekt promijenjen, što uzrokuje suptilne, teško debuggive greške (npr. očekivanje da je original nepromijenjen ali korištenje `upcase!` ga mutira, ili očekivanje mutacije ali korištenje `upcase` ostavlja original nepromijenjen).

Pošto su Ruby stringovi mutable i mnoge metode imaju oba oblika, razumijevanje ove razlike je važno za ispravnost — znajući da `!` obično znači "mijenja na mjestu / je opasna verzija" (konvencija koja se proteže dalje od stringova na druge Ruby metode kao `map!`, `sort!`) možete predvidjeti i kontrolirati ponašanje mutacije.

Dodatna **zamka** da metode sa udarcem vraćaju `nil` kad ne naprave promjenu (što može slomiti lančanje metoda) je također vrijedna znanja.

Razumijevanje Ruby-jevih korisnih string metoda i posebno **razlike između udarca i bez udarca u mutaciji** (jezgrena Ruby konvencija koja utječe na da li je original promijenjen) je važno za pisanje ispravnog Ruby-ja koji sigurno rukuje stringovima — to je česta izvor mutacijskih grešaka, a konvencija `!` je temeljni Ruby idiom koji pokazuje razumijevanje semantike na mjestu u odnosu na novu verziju objekta, što ga čini praktično relevantnim znanjem za stalnu string manipulaciju u Ruby-ju i čestom temom o karakterističnoj, greškom sklonoj Ruby konvenciji.