Welke nuttige String-methodes en bang (!)-varianten zijn er?

Question

Accepted Answer

Ruby-strings hebben een rijke set methoden voor manipulatie, en veel ervan bestaan in twee vormen: een normale versie (retourneert een **nieuw** string) en een **bang (`!`)-versie** (wijzigt het string **in place**, muteert het origineel). Het begrijpen van dit onderscheid is belangrijk voor juistheid en het voorkomen van bugs.

## Veelgebruikte string-methoden

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

## Het cruciale bang (!)-onderscheid: in-place mutatie

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

De **`!` (bang)-versies muteren het originele string in place**, terwijl de versies zonder bang een nieuw string retourneren en het origineel ongewijzigd laten. Dit is een kritiek onderscheid — het gebruik van `upcase!` wanneer je `upcase` bedoelde (of omgekeerd) bepaalt of het origineel wordt gewijzigd, wat subtiele bugs kan veroorzaken.

## Een bang-valstrik: nil-retourwaarde wanneer er geen wijziging is

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

Een subtiele valstrik: bang-methoden retourneren **`nil`** als zij geen wijziging hebben aangebracht — dus het enchainen van hun retourwaarde kan fout gaan.

## Waarom het belangrijk is

String-manipulatie komt veel voor in programmering, dus het kennen van Ruby's rijke string-methoden is nuttige dagelijkse kennis — maar het belangrijkste is het begrijpen van het **bang (`!`) versus niet-bang onderscheid**, dat zowel een Ruby-naamgevingsconventie als een veel voorkomende bron van bugs is.

De niet-bang versie retourneert een **nieuw** string (het origineel ongewijzigd latend), terwijl de **bang-versie het origineel in place muteert** — en het verwarren ervan bepaalt of het originele object wordt gewijzigd, wat subtiele, moeilijk opspoorbare bugs veroorzaakt (bijv. verwachtend dat het origineel ongewijzigd blijft maar `upcase!` gebruikt muteert het, of mutatie verwachtend maar `upcase` gebruikt laat het origineel ongewijzigd).

Omdat Ruby-strings mutable zijn en veel methoden beide vormen hebben, is het begrijpen van dit onderscheid belangrijk voor juistheid — weten dat `!` meestal betekent "wijzigt in place / is de gevaarlijke versie" (een conventie die verder gaat dan strings naar andere Ruby-methoden zoals `map!`, `sort!`) stelt je in staat om mutatie-gedrag te voorspellen en te beheersen.

De aanvullende **valstrik** dat bang-methoden `nil` retourneren wanneer zij geen wijziging maken (wat method chaining kan doorbreken) is ook waardevol om te weten.

Het begrijpen van Ruby's nuttige string-methoden en vooral het **bang/niet-bang mutatie-onderscheid** (een kernconventie van Ruby die bepaalt of het origineel wordt gewijzigd) is belangrijk voor het schrijven van correct Ruby dat strings veilig afhandelt — het is een veel voorkomende bron van mutatie-bugs, en de `!`-conventie is een fundamenteel Ruby-idioom dat begrip van in-place versus new-object-semantiek weerspiegelt, waardoor het praktisch relevante kennis is voor het constante string-werk in Ruby en een veelgesproken onderwerp over een karakteristieke, bug-gevoelige Ruby-conventie.