Ruby Academy · Leçon

Goulots d’étranglement courants

Accélérez le code Ruby

Goulots d’étranglement courants est une leçon Ruby Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Reconnaître les goulots d’étranglement

La plupart des ralentissements de Ruby proviennent de quelques schémas récurrents. Les connaître vous permet de corriger rapidement votre code.

Une structure de données inadaptée à la tâche
Un travail répété qui pourrait être mis en cache
Des requêtes N+1 et des boucles imbriquées

Cette leçon présente les problèmes les plus fréquents.

puts 'Speeding up Ruby starts with knowing the usual suspects'

Array#include? ou Set

Vérifier l’appartenance avec Array#include? coûte O(n). Un Set (ou un hachage) permet des recherches en O(1).

Pour des vérifications répétées d’appartenance, créez un Set une seule fois
Gain de vitesse considérable sur les grandes collections

require 'set'

allowed = Set.new(['a', 'b', 'c'])
puts allowed.include?('b')
puts allowed.include?('z')

Boucles imbriquées (O(n au carré))

Comparer chaque paire d’éléments est une opération quadratique qui devient très coûteuse à mesure que la taille augmente.

Remplacez les boucles internes par une recherche dans un hachage
Transforme O(n au carré) en O(n)

a = [1, 2, 3, 4]
b = [3, 4, 5]
set_b = b.to_set rescue require('set') || b.to_set
common = a.select { |x| set_b.include?(x) }
puts common.inspect

Le schéma N+1

Récupérer des données associées dans une boucle entraîne N+1 opérations.

Une requête pour la liste, puis une par élément
Regroupez plutôt les recherches en une seule récupération groupée

# Bad: lookup inside loop
orders = [1, 2, 3]
prices = { 1 => 10, 2 => 20, 3 => 30 }
# Good: one preloaded hash, O(1) per item
total = orders.sum { |id| prices[id] }
puts total

Mémorisation

Recalculer la même valeur coûteuse fait perdre du temps. Mémorisez-la avec ||=.

Mettez le résultat en cache après le premier calcul
Les appels suivants renvoient le résultat instantanément

class Report
  def total
    @total ||= begin
      puts 'computing...'
      (1..1000).sum
    end
  end
end

r = Report.new
puts r.total
puts r.total

Choisir la bonne méthode

Certaines méthodes d’énumération sont bien plus rapides que des enchaînements de méthodes.

sum est plus efficace que inject(:+)
any? s’arrête dès que possible, contrairement à select.empty?
find s’arrête à la première correspondance

nums = (1..1_000_000)
puts nums.any? { |n| n > 5 }
puts nums.find { |n| n > 5 }

Éviter les tris répétés

Trier dans une boucle ou à plusieurs reprises coûte cher. Triez une fois, puis réutilisez le résultat.

Le tri coûte O(n log n)
Mettez en cache le résultat trié si les données sont stables

data = [5, 2, 8, 1, 9]
sorted = data.sort
puts sorted.first
puts sorted.last

Regroupement par hachage

group_by et tally regroupent et comptabilisent en un seul parcours au lieu d’effectuer des analyses répétées.

tally compte efficacement les occurrences
Évite les boucles de comptage manuelles

words = ['a', 'b', 'a', 'c', 'b', 'a']
puts words.tally.inspect

Coût de la construction des chaînes

Assembler avec join est plus rapide que concaténer à plusieurs reprises pour les collections.

Construisez un tableau, puis appelez join une seule fois
Évite de nombreuses chaînes intermédiaires

parts = (1..5).map { |i| "item#{i}" }
puts parts.join(', ')

Compilation des expressions régulières

Définir un littéral d’expression régulière dans une boucle très sollicitée le recompile implicitement. Sortez-le dans une constante.

Compilez une fois, faites correspondre de nombreuses fois
Utilisez match? lorsque vous n’avez besoin que d’un booléen

EMAIL = /\A[^@\s]+@[^@\s]+\z/

inputs = ['a@b.com', 'nope', 'x@y.org']
valid = inputs.select { |s| EMAIL.match?(s) }
puts valid.inspect

Différer les calculs

Ne calculez pas ce dont vous pourriez ne jamais avoir besoin. Différez les calculs avec une évaluation paresseuse ou des conditions de garde.

Retournez dès que possible
Ne calculez les valeurs coûteuses qu’à la demande

def describe(items)
  return 'empty' if items.empty?
  "#{items.size} items, first is #{items.first}"
end

puts describe([])
puts describe([10, 20])

Vérification rapide

Testez vos connaissances sur les goulots d’étranglement.

Récapitulatif

Vous avez appris à corriger les goulots d’étranglement courants :

Utilisez Set ou un hachage pour rechercher rapidement une appartenance plutôt que include?
Éliminez les boucles imbriquées et les schémas N+1 avec des hachages préchargés
Mémorisez les calculs coûteux avec ||=
Choisissez des méthodes efficaces (sum, any?, tally) et sortez les expressions régulières des boucles
Différez ou ignorez le travail dont vous pourriez ne jamais avoir besoin

Mesurez toujours avant et après pour confirmer le gain.

Questions Fréquemment Posées

La leçon « Goulots d’étranglement courants » est-elle gratuite ?

Oui — le texte complet de « Goulots d’étranglement courants » 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 « Goulots d’étranglement courants » ?

Accélérez le code Ruby 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 4 sur 4.

Combien de temps prend la leçon « Goulots d’étranglement courants » ?

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