Vilka är användbara String-metoder och bang (!)-varianter?

Question

Accepted Answer

Ruby-strängar har en rik uppsättning metoder för manipulation, och många kommer i två former: en normal version (returnerar en **ny** sträng) och en **bang (`!`)**-version (modifierar strängen **på plats**, muterar originalet). Att förstå denna skillnad är viktig för korrekthet och för att undvika fel.

## Vanliga strängmetoder

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

## Den kritiska bang (!)-skillnaden: mutation på plats

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

**`!`-versionerna (bang) muterar den ursprungliga strängen på plats**, medan versionerna utan bang returnerar en ny sträng och lämnar originalet oförändrat. Detta är en kritisk skillnad — att använda `upcase!` när du menade `upcase` (eller vice versa) ändrar huruvida originalet modifieras, vilket kan orsaka subtila fel.

## En bang-gotcha: nil-retur när ingen förändring görs

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

En subtil gotcha: bang-metoder returnerar **`nil`** om de inte gjorde någon förändring — så att kedja från deras returvärde kan gå sönder.

## Varför det spelar roll

Strängmanipulation är genomgripande i programmering, så att kunna Rubys rika strängmetoder är användbar kunskap för dagligt bruk — men den viktigaste punkten är att förstå **bang (`!`)-skillnaden jämfört med utan bang**, vilket är både en Ruby-namngivningskonvention och en frekvent källa till fel.

Versionen utan bang returnerar en **ny** sträng (lämnar originalet oförändrat), medan **bang-versionen muterar originalet på plats** — och att blanda ihop dem ändrar huruvida originalobjektet modifieras, vilket orsakar subtila, svårfelsökta fel (t.ex. förväntar sig att originalet är oförändrat men använder `upcase!` som muterar det, eller förväntar sig mutation men använder `upcase` som lämnar originalet oförändrat).

Eftersom Ruby-strängar är muterbara och många metoder har båda formerna, är det viktigt att förstå denna skillnad för korrekthet — att veta att `!` vanligtvis betyder "modifierar på plats / är den farliga versionen" (en konvention som sträcker sig bortom strängar till andra Ruby-metoder som `map!`, `sort!`) låter dig förutsäga och kontrollera mutationsbeteende.

Den ytterligare **gotchan** att bang-metoder returnerar `nil` när de inte gör någon förändring (vilket kan bryta metodkedja) är också värd att veta.

Att förstå Rubys användbara strängmetoder och särskilt **bang/utan bang-mutationsskillnaden** (en kärnkonvention i Ruby som påverkar huruvida originalet modifieras) är viktigt för att skriva korrekt Ruby som hanterar strängar säkert — det är en frekvent källa till mutationsfel, och `!`-konventionen är en grundläggande Ruby-idiom som återspeglar förståelse för semantik för mutation på plats jämfört med nya objekt, vilket gör det praktiskt relevant kunskap för det konstanta strängarbetet i Ruby och ett vanligt ämne om en karakteristisk, felbenägen Ruby-konvention.