Какие полезные методы String и варианты с восклицательным знаком (!) существуют?

Question

Accepted Answer

Строки в Ruby имеют богатый набор методов для манипуляции, и многие из них существуют в двух формах: обычная версия (возвращает **новую** строку) и версия с восклицательным знаком (`!`) (изменяет строку **на месте**, мутирует оригинал). Понимание этого различия важно для корректности и избежания ошибок.

## Обычные методы строк

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

## Критическое различие восклицательного знака (!): мутация на месте

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

**Версии с `!` (восклицательным знаком) мутируют оригинальную строку на месте**, в то время как версии без восклицательного знака возвращают новую строку и оставляют оригинал неизменным. Это критическое различие — использование `upcase!` вместо `upcase` (или наоборот) изменяет, будет ли оригинал модифицирован, что может привести к тонким ошибкам.

## Подводный камень восклицательного знака: возврат nil при отсутствии изменений

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

Тонкий подводный камень: методы с восклицательным знаком возвращают **`nil`** если они не внесли изменений — поэтому связывание вызовов на их возвращаемое значение может привести к ошибке.

## Почему это важно

Манипуляция со строками повсеместна в программировании, поэтому знание богатого набора методов строк в Ruby — это полезное повседневное знание — но самая важная точка — это понимание различия **между восклицательным знаком (`!`) и его отсутствием**, что является как соглашением об именовании в Ruby, так и частой источником ошибок.

Версия без восклицательного знака возвращает **новую** строку (оставляя оригинал неизменным), в то время как **версия с восклицательным знаком мутирует оригинал на месте** — и путаница между ними изменяет, будет ли модифицирован оригинальный объект, что приводит к тонким, сложным в отладке ошибкам (например, ожидание неизменённого оригинала, но использование `upcase!` мутирует его, или ожидание мутации, но использование `upcase` оставляет оригинал нетронутым).

Поскольку строки в Ruby изменяемы и многие методы имеют обе формы, понимание этого различия важно для корректности — знание того, что `!` типично означает «изменяет на месте / опасная версия» (соглашение, распространяющееся за пределы строк на другие методы Ruby, такие как `map!`, `sort!`), позволяет вам предсказать и контролировать поведение мутации.

Дополнительный **подводный камень**, что методы с восклицательным знаком возвращают `nil` когда они не делают изменений (что может сломать связывание методов), также полезно знать.

Понимание полезных методов строк Ruby и особенно различия **между восклицательным знаком и его отсутствием** (фундаментальное соглашение Ruby, влияющее на то, будет ли модифицирован оригинал) важно для написания корректного Ruby, который безопасно обрабатывает строки — это частый источник ошибок мутации, и соглашение `!` — это фундаментальный идиом Ruby, который отражает понимание семантики изменения на месте и создания нового объекта, делая это практически релевантным знанием для постоянной работы со строками в Ruby и частой темой о характерном, подверженном ошибкам соглашении Ruby.