Melyek a hasznos String metódusok és a bang (!) variánsok?

Question

Accepted Answer

A Ruby stringek gazdag metóduskészlettel rendelkeznek a manipulációhoz, és sok metódus két formában létezik: egy normál verzió (új stringet ad vissza) és egy **bang (`!`)** verzió (a stringet **helyben módosítja**, mutálja az eredetit). E különbség megértése fontos a helyességhez és a hibák elkerüléséhez.

## Gyakori string metódusok

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

## A kritikus bang (!) különbség: helyben történő mutáció

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

A **`!` (bang) verziók helyben mutálják az eredeti stringet**, míg a nem-bang verziók egy új stringet adnak vissza és az eredeti változatlan marad. Ez egy kritikus különbség — ha `upcase!` helyett `upcase`-t használsz (vagy fordítva), az megváltoztatja, hogy az eredeti módosul-e vagy sem, ami finom hibákat okozhat.

## Egy bang csapda: nil visszatérítés, ha nem történt változás

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

Egy finom csapda: a bang metódusok **`nil`-t adnak vissza**, ha nem történt változás — ezért a visszatérítési értékről történő láncozás megtörheti a kódot.

## Miért fontos

A string manipuláció mindennapos a programozásban, így a Ruby gazdag string metódusainak ismerete hasznos napi tudás — de a legfontosabb pont a **bang (`!`) vs nem-bang különbség megértése**, amely egyrészt egy Ruby elnevezési konvenció, másrészt a hibák gyakori forrása.

A nem-bang verzió egy **új** stringet ad vissza (az eredeti változatlan marad), míg a **bang verzió helyben mutálja az eredetit** — és e kettő összetévesztése megváltoztatja, hogy az eredeti objektum módosul-e, ami finom, nehéz debuggolható hibákat okoz (például azt várva, hogy az eredeti változatlan marad, de a `upcase!` használata mutálja azt, vagy mutációra számítva a `upcase` az eredeti érintetlenül hagyja).

Mivel a Ruby stringek mutálhatóak és sok metódusnak van mindkét formája, e különbség megértése fontos a helyességhez — tudván, hogy a `!` jellemzően azt jelenti "helyben módosít / a veszélyes verzió" (egy konvenció, amely stringeken túl más Ruby metódusokra is kiterjed, mint `map!`, `sort!`), megjósolhatod és szabályozhatod a mutáció viselkedését.

A további **csapda**, hogy a bang metódusok `nil`-t adnak vissza, ha nem történt változás (amely megtörheti a metódus láncozást), szintén értékes ismeret.

A Ruby hasznos string metódusainak és különösen a **bang/nem-bang mutáció különbségének** megértése (egy core Ruby konvenció, amely azt befolyásolja, hogy az eredeti módosul-e) fontos a helyes Ruby kód írásához, amely biztonságosan kezel stringeket — ez a mutáció hibáinak gyakori forrása, és a `!` konvenció egy alapvető Ruby idioma, amely az in-place vs. új objektum szemantikájának megértését tükrözi, így gyakorlatilag releváns tudás a Ruby-ban történő állandó string munkához és egy gyakori téma a Ruby jellegzetes, hibára hajlamos konvenciójáról.