Ruby Academy · Leçon

Définir des modules

Espaces de noms et méthodes

Définir des modules est une leçon Ruby Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Espaces de noms et méthodes

Un module est un conteneur pour les méthodes et les constantes. Contrairement à une classe, vous ne pouvez pas créer d’instance d’un module. Les modules ont deux fonctions : regrouper le code (espace de noms) et partager un comportement (mélanges).

module Greeter
  def self.hello
    "Hello from the module"
  end
end
puts Greeter.hello

Méthodes de module

Définissez une méthode avec self. pour l’appeler directement sur le module, comme une fonction utilitaire. On les appelle souvent des fonctions de module.

module MathTools
  def self.square(x)
    x * x
  end
end
puts MathTools.square(7)

Constantes de module

Les modules contiennent également des constantes. Accédez-y avec l’opérateur de portée ::.

module Physics
  GRAVITY = 9.81
end
puts Physics::GRAVITY

Placer des classes dans un espace de noms

Placez les classes dans un module pour éviter les collisions de noms. Le nom complet utilise ::.

module Store
  class Item
    def initialize(name)
      @name = name
    end
    def to_s
      @name
    end
  end
end
puts Store::Item.new("Book")

Pourquoi les espaces de noms sont importants

Deux bibliothèques peuvent toutes deux définir un Logger. Les espaces de noms les maintiennent séparées : Audio::Logger et Network::Logger n’entrent jamais en conflit.

module Audio
  class Logger
    def name; "audio logger"; end
  end
end
module Network
  class Logger
    def name; "network logger"; end
  end
end
puts Audio::Logger.new.name
puts Network::Logger.new.name

module_function

module_function rend les méthodes suivantes appelables à la fois sur le module et comme méthodes d’instance privées lorsqu’elles sont incluses. Cela évite de répéter self..

module Calc
  module_function
  def add(a, b)
    a + b
  end
end
puts Calc.add(2, 3)

Regrouper des constantes associées

Les modules sont parfaits pour organiser des valeurs de configuration associées sous un nom clair et unique.

module Color
  RED = "#FF0000"
  GREEN = "#00FF00"
  BLUE = "#0000FF"
end
puts Color::GREEN

Modules imbriqués

Les modules peuvent être imbriqués dans d’autres modules pour une organisation plus approfondie.

module App
  module Config
    VERSION = "1.0"
  end
end
puts App::Config::VERSION

Répertorier le contenu d’un module

Les méthodes d’introspection vous permettent d’examiner les constantes et les méthodes d’un module lors de l’exécution.

module Settings
  WIDTH = 80
  HEIGHT = 24
end
p Settings.constants

Les modules ne peuvent pas être instanciés

Essayer Module.new avec un module nommé échoue, car un module ne possède pas de constructeur pour les instances. Il sert d’espace de noms et de conteneur de comportements, et non de modèle pour les objets.

module Tools
end
begin
  Tools.new
rescue NoMethodError => e
  puts "Cannot instantiate: #{e.message}"
end

Mise en pratique

Les modules organisent et partagent le code :

Utilisez self.method pour les fonctions de module appelables.
Ils contiennent des constantes accessibles avec ::.
Placez les classes dans un espace de noms pour éviter les collisions.
Vous ne pouvez pas instancier un module.

module Geometry
  PI = 3.14159
  def self.circle_area(r)
    PI * r * r
  end
end
puts Geometry.circle_area(2)

Vérification rapide

Vérifiez votre compréhension des modules.

Récapitulatif

Vous avez appris à définir des modules :

Les modules regroupent les méthodes et les constantes.
self.method définit des fonctions de module appelables.
:: permet d’accéder aux constantes et aux classes imbriquées.
Les espaces de noms empêchent les collisions de noms.

module Util
  def self.shout(s)
    s.upcase + "!"
  end
end
puts Util.shout("ruby")

Questions Fréquemment Posées

La leçon « Définir des modules » est-elle gratuite ?

Oui — le texte complet de « Définir des modules » 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 « Définir des modules » ?

Espaces de noms et méthodes 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 1 sur 4.

Combien de temps prend la leçon « Définir des modules » ?

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