Freezing an object (.freeze) makes it immutable — it can no longer be modified. The common use is frozen string literals, which improve performance (strings are reused instead of re-allocated) and prevent accidental mutation. Modern Ruby encourages frozen strings.
config = { }.freeze
config[] =
= .freeze
str = .freeze
str.frozen?
str <<
.freeze prevents any further modification of an object — useful for constants and shared data that shouldn't change (protecting against accidental mutation bugs).
# 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
String literals are normally mutable, so each occurrence allocates a new object. Frozen string literals are immutable and reused — identical strings share one object, reducing allocations and GC pressure (a meaningful performance benefit in hot code).
# 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
Adding # frozen_string_literal: true at the top of a file makes all its string literals frozen automatically — a recommended modern practice for performance and to catch accidental mutations. (To create a mutable copy, use +"string" or .dup.)
Understanding object freezing and frozen string literals is valuable Ruby knowledge for both performance and correctness. Freezing (.freeze) makes objects immutable, which is useful for protecting constants and shared data from accidental modification — preventing a class of mutation bugs (especially important since Ruby strings are mutable by default and can be unexpectedly changed).
The most impactful application is frozen string literals, which address a real Ruby performance characteristic: because string literals are normally mutable, each occurrence of a literal like "hello" allocates a new object, and in hot code this creates significant allocation and GC pressure. Frozen string literals are immutable and reused (identical literals share one object), reducing allocations and improving performance — a meaningful optimization.
The # frozen_string_literal: true magic comment (freezing all string literals in a file) is a recommended modern Ruby practice that provides this performance benefit and catches accidental string mutations, and it's increasingly common (and will likely become the default in future Ruby).
Understanding freezing (immutability for constants and shared data), the performance benefit of frozen string literals (reuse instead of re-allocation, reducing GC pressure), and the magic comment as a modern best practice is valuable for writing performant, correct Ruby.
Since string allocation is a notable performance factor in Ruby, and since frozen string literals are an increasingly standard practice for both performance and preventing mutation bugs, understanding freezing and frozen strings is important senior-level knowledge that reflects awareness of Ruby performance optimization and modern best practices — distinguishing performance-conscious Ruby developers and a relevant topic for writing efficient, robust Ruby code.