Jaké jsou užitečné metody String a varianty s vykřičníkem (!)?

Question

Accepted Answer

Ruby stringy mají bohatou sadu metod pro manipulaci a mnohé z nich existují ve dvou formách: normální verze (vrací **nový** string) a verze s **vykřičníkem (`!`)** (modifikuje string **na místě**, mění originál). Pochopení tohoto rozdílu je důležité pro korektnost a vyhýbání se chybám.

## Běžné metody 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
```

## Zásadní rozdíl s vykřičníkem (!): mutace na místě

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

**Verze s `!` (vykřičníkem) mutují originální string na místě**, zatímco verze bez vykřičníku vrací nový string a nechávají originál nezměněný. Toto je zásadní rozdíl — použití `upcase!` když jste mysleli `upcase` (nebo obráceně) změní, zda je originál modifikován, což může způsobit jemné chyby.

## Gotcha s vykřičníkem: vrácení nil když nedojde k žádné změně

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

Jemné gotcha: metody s vykřičníkem vrací **`nil`** pokud nedělají žádnou změnu — takže řetězení jejich návratové hodnoty může zlomit.

## Proč na tom záleží

Manipulace s stringy je všudypřítomná v programování, takže znalost bohaté sady metod Ruby pro stringy je užitečná každodenní znalost — ale nejdůležitější bod je pochopení **rozdílu mezi vykřičníkem (`!`) a bez vykřičníku**, který je jak Ruby konvencí pojmenování tak i velmi častým zdrojem chyb.

Verze bez vykřičníku vrací **nový** string (originál zůstává nezměněný), zatímco **verze s vykřičníkem mutuje originál na místě** — a jejich záměna změní, zda je originální objekt modifikován, což způsobuje jemné, těžko laditelné chyby (např. očekáváte, že originál zůstane nezměněný, ale použijete `upcase!` který jej mutuje, nebo očekáváte mutaci ale použijete `upcase` který originál ponechá nedotčený).

Protože jsou Ruby stringy měnitelné a mnoho metod má obě formy, pochopení tohoto rozdílu je důležité pro korektnost — vědomí, že `!` obvykle znamená "modifikuje na místě / je nebezpečná verze" (konvence rozšiřující se mimo stringy na jiné Ruby metody jako `map!`, `sort!`) vám umožňuje předvídat a kontrolovat chování mutace.

Další **gotcha**, že metody s vykřičníkem vrací `nil` když nedělají žádnou změnu (což může porušit řetězení metod), je také užitečné vědět.

Pochopení užitečných metod Ruby stringů a zvláště **rozdílu mezi vykřičníkem a bez vykřičníku** (základní Ruby konvence ovlivňující, zda je originál modifikován) je důležité pro psaní korektního Ruby, který bezpečně zachází se stringy — je to časté zdroj mutačních chyb, a konvence `!` je základní Ruby idiom, který odráží pochopení sémantiky mutace na místě vs. nového objektu, což jej činí prakticky relevantní znalostí pro neustálou práci se stringy v Ruby a běžné téma o distinktivní, na chyby náchylné Ruby konvenci.