Quais são os métodos úteis de String e as variantes com bang (!)?

Question

Accepted Answer

Strings em Ruby têm um rico conjunto de métodos para manipulação, e muitos vêm em duas formas: uma versão normal (retorna uma **nova** string) e uma versão **bang (`!`)** (modifica a string **in place**, mutando a original). Entender essa distinção é importante para correção e para evitar bugs.

## Métodos comuns de 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
```

## A distinção crucial do bang (!): mutação in-place

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

As versões **`!` (bang) mutam a string original in place**, enquanto as versões sem bang retornam uma nova string e deixam a original inalterada. Esta é uma distinção crítica — usar `upcase!` quando você quis `upcase` (ou vice-versa) muda se o original é modificado, o que pode causar bugs sutis.

## Uma armadilha do bang: retorno nil quando não há mudança

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

Uma armadilha sutil: métodos bang retornam **`nil`** se não fizeram nenhuma mudança — então encadear sobre seu valor de retorno pode quebrar.

## Por que isso importa

Manipulação de strings é onipresente em programação, então conhecer os ricos métodos de string do Ruby é conhecimento útil no dia a dia — mas o ponto mais importante é entender a **distinção entre bang (`!`) e não-bang**, que é tanto uma convenção de nomenclatura do Ruby quanto uma fonte frequente de bugs.

A versão sem bang retorna uma **nova** string (deixando a original inalterada), enquanto a **versão bang muta a original in place** — e confundi-las muda se o objeto original é modificado, o que causa bugs sutis e difíceis de debugar (por exemplo, esperando que o original permaneça inalterado mas usando `upcase!` o muta, ou esperando mutação mas usando `upcase` deixa o original intocado).

Como strings do Ruby são mutáveis e muitos métodos têm ambas as formas, entender essa distinção é importante para correção — saber que `!` tipicamente significa "modifica in place / é a versão perigosa" (uma convenção que se estende além de strings para outros métodos do Ruby como `map!`, `sort!`) permite que você preveja e controle o comportamento de mutação.

A **armadilha** adicional de que métodos bang retornam `nil` quando não fazem nenhuma mudança (o que pode quebrar encadeamento de métodos) também é valiosa conhecer.

Entender os úteis métodos de string do Ruby e especialmente a **distinção mutação bang/não-bang** (uma convenção principal do Ruby afetando se o original é modificado) é importante para escrever Ruby correto que manipula strings com segurança — é uma fonte frequente de bugs de mutação, e a convenção `!` é um idioma fundamental do Ruby que reflete compreensão da semântica in-place vs. novo objeto, tornando-a conhecimento praticamente relevante para o trabalho constante com strings em Ruby e um tópico comum sobre uma convenção Ruby distintiva e propensa a bugs.