¿Qué hace congelar objetos y por qué usar literales de cadena congeladas?

Question

Accepted Answer

**Congelar** un objeto (`.freeze`) lo hace **inmutable** — ya no puede ser modificado. El uso común es **literales de cadena congeladas**, que mejoran el rendimiento (las cadenas se reutilizan en lugar de reasignarse) y previenen mutaciones accidentales. Ruby moderno fomenta las cadenas congeladas.

## freeze hace los objetos inmutables

```ruby
config = { api_key: "secret" }.freeze
config[:api_key] = "new"    # ❌ FrozenError — can't modify a frozen object

NAME = "Application".freeze   # freeze constants to prevent accidental modification

str = "hello".freeze
str.frozen?                  # true
str << " world"              # ❌ FrozenError
```

`.freeze` previene cualquier modificación adicional de un objeto — útil para constantes y datos compartidos que no deberían cambiar (protegiendo contra errores de mutación accidental).

## El problema de rendimiento que resuelven las cadenas congeladas

```ruby
# WITHOUT frozen string literals: each "hello" creates a NEW string object
1000.times { x = "hello" }    # 1000 separate string objects allocated! (GC pressure)

# WITH frozen string literals: identical literals are REUSED (one shared object)
1000.times { x = "hello" }    # reuses the SAME frozen "hello" object → efficient
```

Los literales de cadena normalmente son mutables, así que cada ocurrencia asigna un nuevo objeto. **Los literales de cadena congelados son inmutables y se reutilizan** — cadenas idénticas comparten un objeto, reduciendo asignaciones y presión de GC (un beneficio de rendimiento significativo en código crítico).

## El comentario mágico (habilitado por archivo)

```ruby
# frozen_string_literal: true     # ← magic comment at the TOP of the file

# now ALL string literals in this file are automatically frozen (immutable + reused)
def greet
  "hello"    # this literal is frozen → reused, not re-allocated
end
```

Agregar **`# frozen_string_literal: true`** al inicio de un archivo congela automáticamente todos sus literales de cadena — una práctica moderna recomendada para rendimiento y para detectar mutaciones accidentales. (Para crear una copia mutable, usa `+"cadena"` o `.dup`.)

## Por qué es importante

Comprender el congelamiento de objetos y literales de cadena congelados es conocimiento valioso de Ruby tanto para rendimiento como para corrección. **Congelar** (`.freeze`) hace los objetos inmutables, lo cual es útil para proteger constantes y datos compartidos de modificaciones accidentales — previniendo una clase de errores de mutación (especialmente importante ya que las cadenas de Ruby son mutables por defecto y pueden cambiar inesperadamente).

La aplicación más impactante son **literales de cadena congelados**, que abordan una característica real de rendimiento de Ruby: porque los literales de cadena normalmente son mutables, cada ocurrencia de un literal como `"hello"` asigna un *nuevo* objeto, y en código crítico esto crea presión significativa de asignación y GC. **Los literales de cadena congelados son inmutables y se reutilizan** (literales idénticos comparten un objeto), reduciendo asignaciones y mejorando rendimiento — una optimización significativa.

El **comentario mágico `# frozen_string_literal: true`** (congelando todos los literales de cadena en un archivo) es una práctica moderna de Ruby recomendada que proporciona este beneficio de rendimiento y detecta mutaciones accidentales de cadenas, y es cada vez más común (y probablemente se convertirá en el predeterminado en Ruby futuro).

Comprender el congelamiento (inmutabilidad para constantes y datos compartidos), el beneficio de rendimiento de literales de cadena congelados (reutilización en lugar de reasignación, reduciendo presión de GC), y el comentario mágico como una práctica moderna es valioso para escribir Ruby performante y correcto.

Como la asignación de cadenas es un factor de rendimiento notable en Ruby, y como los literales de cadena congelados son una práctica cada vez más estándar tanto para rendimiento como para prevenir errores de mutación, comprender el congelamiento y las cadenas congeladas es conocimiento importante a nivel senior que refleja conciencia de optimización de rendimiento de Ruby y prácticas modernas — distinguiendo desarrolladores de Ruby conscientes del rendimiento y un tema relevante para escribir código Ruby eficiente y robusto.