¿Cuáles son los métodos de String útiles y sus variantes con bang (!)?

Question

Accepted Answer

Los strings de Ruby tienen un conjunto rico de métodos para manipulación, y muchos vienen en dos formas: una versión normal (devuelve un **nuevo** string) y una versión **bang (`!`)** (modifica el string **en el lugar**, mutando el original). Entender esta distinción es importante para la corrección y evitar bugs.

## Métodos de string comunes

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

## La distinción crucial de bang (!): mutación en el lugar

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

Las **versiones `!` (bang) mutan el string original en el lugar**, mientras que las versiones sin bang devuelven un nuevo string y dejan el original sin cambios. Esta es una distinción crítica — usar `upcase!` cuando quisiste `upcase` (o viceversa) cambia si el original se modifica, lo que puede causar bugs sutiles.

## Una trampa de bang: retorno nil cuando no hay cambio

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

Una trampa sutil: los métodos bang retornan **`nil`** si no hicieron cambio — así que encadenar en su valor de retorno puede romper.

## Por qué es importante

La manipulación de strings es ubicua en la programación, así que conocer los métodos de string ricos de Ruby es un conocimiento útil cotidiano — pero el punto más importante es entender la **distinción de bang (`!`) vs sin bang**, que es tanto una convención de nomenclatura de Ruby como una fuente frecuente de bugs.

La versión sin bang devuelve un **nuevo** string (dejando el original sin cambios), mientras que la **versión bang muta el original en el lugar** — y confundirlas cambia si el objeto original se modifica, lo que causa bugs sutiles y difíciles de depurar (p. ej., esperando que el original no cambie pero usando `upcase!` lo muta, o esperando mutación pero usando `upcase` deja el original sin tocar).

Ya que los strings de Ruby son mutables y muchos métodos tienen ambas formas, entender esta distinción es importante para la corrección — saber que `!` típicamente significa "modifica en el lugar / es la versión peligrosa" (una convención que se extiende más allá de strings a otros métodos de Ruby como `map!`, `sort!`) te deja predecir y controlar el comportamiento de mutación.

La **trampa** adicional de que los métodos bang retornan `nil` cuando no hacen cambio (lo que puede romper el encadenamiento de métodos) también es valiosa saber.

Entender los métodos de string útiles de Ruby y especialmente la **distinción mutación bang/sin bang** (una convención de Ruby central que afecta si el original se modifica) es importante para escribir Ruby correcto que maneje strings de forma segura — es una fuente frecuente de bugs de mutación, y la convención `!` es un idioma fundamental de Ruby que refleja la comprensión de la semántica de en-el-lugar vs. nuevo-objeto, haciéndola un conocimiento prácticamente relevante para el trabajo constante de strings en Ruby y un tema común sobre una convención distintiva de Ruby propensa a bugs.