Freezing un objet (.freeze) le rend immutable — il ne peut plus être modifié. L'utilisation courante est les littéraux de chaîne gelés, qui améliorent les performances (les chaînes sont réutilisées au lieu d'être réallouées) et préviennent les mutations accidentelles. Ruby moderne encourage les chaînes gelées.
config = { }.freeze
config[] =
= .freeze
str = .freeze
str.frozen?
str <<
.freeze empêche toute modification ultérieure d'un objet — utile pour les constantes et les données partagées qui ne doivent pas changer (protection contre les bugs de mutation accidentelle).
# 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
Les littéraux de chaîne sont normalement mutables, donc chaque occurrence alloue un nouvel objet. Les littéraux de chaîne gelés sont immutables et réutilisés — les chaînes identiques partagent un seul objet, réduisant les allocations et la pression GC (un bénéfice de performance significatif dans le code critique).
# 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
Ajouter # frozen_string_literal: true en haut d'un fichier gèle automatiquement tous ses littéraux de chaîne — une pratique recommandée et moderne pour la performance et pour détecter les mutations accidentelles. (Pour créer une copie mutable, utilisez +"string" ou .dup.)
Comprendre le verrouillage des objets et les littéraux de chaîne gelés est une connaissance Ruby précieuse à la fois pour la performance et la correction. Freezing (.freeze) rend les objets immutables, ce qui est utile pour protéger les constantes et les données partagées des modifications accidentelles — prévenant une classe de bugs de mutation (particulièrement important puisque les chaînes Ruby sont mutables par défaut et peuvent être modifiées de manière inattendue).
L'application la plus impactante est les littéraux de chaîne gelés, qui répondent à une caractéristique réelle de performance de Ruby : parce que les littéraux de chaîne sont normalement mutables, chaque occurrence d'un littéral comme "hello" alloue un nouvel objet, et dans le code critique cela crée une allocation significative et une pression GC. Les littéraux de chaîne gelés sont immutables et réutilisés (les littéraux identiques partagent un seul objet), réduisant les allocations et améliorant la performance — une optimisation significative.
Le commentaire magique # frozen_string_literal: true (geler tous les littéraux de chaîne d'un fichier) est une pratique Ruby moderne recommandée qui fournit ce bénéfice de performance et détecte les mutations de chaîne accidentelles, et c'est de plus en plus courant (et deviendra probablement le défaut dans les futures versions de Ruby).
Comprendre le freezing (immuabilité pour les constantes et les données partagées), le bénéfice de performance des littéraux de chaîne gelés (réutilisation au lieu de réallocation, réduisant la pression GC), et le commentaire magique comme bonne pratique moderne est précieux pour écrire du Ruby performant et correct.
Puisque l'allocation de chaîne est un facteur de performance notable en Ruby, et puisque les littéraux de chaîne gelés sont une pratique de plus en plus standard à la fois pour la performance et la prévention des bugs de mutation, comprendre le freezing et les chaînes gelées est une connaissance Ruby de haut niveau important qui reflète une sensibilisation à l'optimisation des performances Ruby et aux meilleures pratiques modernes — distinguant les développeurs Ruby conscients des performances et un sujet pertinent pour écrire du code Ruby efficace et robuste.