Ruby Academy · Leçon

Optimisation de la mémoire

Q: La leçon « Optimisation de la mémoire » est-elle gratuite ?

Oui — le texte complet de « Optimisation de la mémoire » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Ruby Academy, passe à CoddyKit PRO. Le cours Ruby Academy comprend 4 leçons au total.

Q: Qu'est-ce que j'apprendrai dans « Optimisation de la mémoire » ?

Réduisez les allocations Tu pratiques Ruby Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Q: Dois-je avoir de l'expérience pour commencer Ruby Academy ?

Aucune expérience préalable n'est requise. Ruby Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Q: Combien de temps prend la leçon « Optimisation de la mémoire » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Q: Peux-tu écrire et exécuter du code dans cette leçon Ruby Academy ?

Oui. Chaque leçon Ruby Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Réduisez les allocations

Optimisation de la mémoire est une leçon Ruby Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Ruby Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Ruby Academy comprend 4 leçons au total.

Pourquoi la mémoire compte

Chaque objet créé par Ruby consomme de la mémoire et augmente le travail du ramasse-miettes. Moins d’allocations signifie des programmes plus rapides et plus légers.

Le GC s’interrompt pour récupérer les objets
Des taux d’allocation élevés déclenchent davantage d’exécutions du GC
Réduire les allocations constitue souvent le gain le plus important

before = GC.stat(:total_allocated_objects)
100.times { 'new string' + '!' }
after = GC.stat(:total_allocated_objects)
puts "Allocated: #{after - before} objects"

Compter les allocations

GC.stat expose des compteurs d’allocation dont vous pouvez calculer la différence autour d’un bloc.

:total_allocated_objects augmente indéfiniment
Calculez la différence avant et après pour mesurer une section

def allocations
  before = GC.stat(:total_allocated_objects)
  yield
  GC.stat(:total_allocated_objects) - before
end

puts allocations { Array.new(1000) { |i| i.to_s } }

Littéraux de chaînes figés

Chaque littéral de chaîne répété alloue un nouvel objet. Le figement permet à Ruby de réutiliser une seule instance immuable.

Ajoutez le commentaire magique en haut d’un fichier
Ou appelez .freeze sur des littéraux individuels

# frozen_string_literal: true

s1 = 'hello'
s2 = 'hello'
puts s1.equal?(s2)

Éviter les allocations dans les boucles

Créer des objets dans des boucles intensives multiplie les allocations. Sortez les constantes de la boucle.

Construisez une fois les expressions régulières, les tableaux et les chaînes
Réutilisez-les entre les itérations

PATTERN = /\d+/

def count_numbers(lines)
  lines.count { |line| line.match?(PATTERN) }
end

puts count_numbers(['a1', 'bb', 'c3'])

Méthodes mutantes (bang)

Les méthodes sans bang renvoient de nouveaux objets ; les méthodes bang modifient l’objet sur place, ce qui économise des allocations.

map!, gsub!, sort!
Utilisez-les uniquement lorsque la modification de l’original est sans danger

arr = [3, 1, 2]
arr.sort!
puts arr.inspect

s = 'hello world'
s.upcase!
puts s

Symboles ou chaînes comme clés

Les symboles sont internés : un même symbole correspond à un seul objet partagé. Utilisez-les comme clés de hachage.

Les clés de chaîne allouent une nouvelle chaîne à chaque fois
Les symboles économisent de la mémoire lors des recherches répétées

puts :name.equal?(:name)
puts 'name'.equal?('name')

Énumérateurs paresseux

Enchaîner map et select construit des tableaux intermédiaires. lazy traite les éléments un par un.

Aucune collection intermédiaire n’est allouée
Idéal pour les séquences volumineuses ou infinies

result = (1..Float::INFINITY).lazy
  .select { |n| n.even? }
  .map { |n| n * n }
  .first(5)
puts result.inspect

Diffuser au lieu de charger

Lire un fichier entier en mémoire est coûteux. Traitez-le en flux ligne par ligne à la place.

each_line traite une ligne à la fois
Mémoire constante quelle que soit la taille du fichier

text = "line1\nline2\nline3"
text.each_line do |line|
  puts line.strip.upcase
end

Concaténation de chaînes

Construire des chaînes avec + dans une boucle alloue une nouvelle chaîne à chaque fois. Utilisez << pour ajouter sur place.

+ crée un nouvel objet
<< modifie le tampon existant

buffer = String.new
5.times { |i| buffer << "item#{i} " }
puts buffer

Mise en commun et réutilisation des objets

Réutilisez les objets coûteux au lieu de les recréer.

Mettez en cache les config analysées ou les expressions régulières compilées
Utilisez une valeur constante ou mémorisée

def config
  @config ||= { host: 'localhost', port: 4567 }
end

puts config.equal?(config)

Déclencher le GC pour obtenir des informations

Vous pouvez examiner le comportement du GC pour confirmer les améliorations.

GC.stat(:count) indique combien d’exécutions du GC ont eu lieu
Moins d’exécutions après l’optimisation est un bon signe

start = GC.stat(:count)
50_000.times { |i| [i] }
puts "GC runs: #{GC.stat(:count) - start}"

Vérification rapide

Testez vos connaissances sur l’optimisation de la mémoire.

Récapitulatif

Vous avez appris à optimiser la mémoire :

Comptez les allocations avec GC.stat
Gelez les littéraux de chaînes et réutilisez les objets
Préférez les méthodes bang et << pour éviter de nouveaux objets
Utilisez des symboles comme clés et des énumérateurs paresseux pour les chaînes de traitement
Traitez les grandes quantités de données en flux au lieu de tout charger

Vous vous attaquerez ensuite aux goulots d’étranglement courants en matière de performances.

Questions Fréquemment Posées

La leçon « Optimisation de la mémoire » est-elle gratuite ?

Oui — le texte complet de « Optimisation de la mémoire » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Ruby Academy, passe à CoddyKit PRO. Le cours Ruby Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Optimisation de la mémoire » ?

Réduisez les allocations Tu pratiques Ruby Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Ruby Academy ?

Aucune expérience préalable n'est requise. Ruby Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Optimisation de la mémoire » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Ruby Academy ?

Oui. Chaque leçon Ruby Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Ruby Academy