Ruby Academy · Leçon

Validations et requêtes

Intégrité et interrogation des données

Validations et requêtes 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.

Pourquoi valider ?

Les validations protègent vos données avant leur arrivée dans la base de données. Elles s'exécutent lorsque vous enregistrez un enregistrement et rejettent les données non valides en affichant des messages utiles.

Elles empêchent les mauvaises données d'entrer (noms manquants, adresses e-mail mal formées).
Elles s'exécutent dans Ruby, ce qui facilite l'affichage des messages aux utilisateurs.
Elles complètent les contraintes de la base de données, mais ne les remplacent pas.

Validation de présence

La règle la plus courante est validates :field, presence: true : elle exige une valeur non vide. Un enregistrement sans cette valeur échoue et enregistre une erreur.

class User < ApplicationRecord
  validates :name, presence: true
end

# User.create(name: "") fails to save

Validation d'unicité

uniqueness: true empêche les valeurs en double, par exemple lorsque deux utilisateurs ont la même adresse e-mail. Associez cette validation à un index unique dans la base de données, car la validation seule présente une condition de concurrence en cas de forte simultanéité.

class User < ApplicationRecord
  validates :email, presence: true, uniqueness: true
end

Format et longueur

Autres validateurs intégrés :

length: { minimum: 8 } pour limiter la taille.
format: { with: /regex/ } pour les motifs.
numericality: true pour les nombres.
inclusion: { in: [...] } pour les valeurs autorisées.

class User < ApplicationRecord
  validates :password, length: { minimum: 8 }
  validates :age, numericality: { greater_than: 0 }
end

Validation et errors

Appelez valid? pour exécuter les validations sans enregistrer. Après un enregistrement échoué, record.errors contient les problèmes et errors.full_messages fournit des chaînes lisibles pour l'interface.

user = User.new(name: "")
if user.valid?
  user.save
else
  puts user.errors.full_messages
end

Enregistrer ou enregistrer avec exception

Deux styles d'enregistrement :

save renvoie true/false, ce qui vous permet d'orienter l'exécution selon le résultat.
save! lève RecordInvalid en cas d'échec, ce qui est utile lorsque les données non valides doivent provoquer une exception.

Le même schéma s'applique à create/create! et à update/update!.

user.save   # => false if invalid
user.save!  # => raises if invalid

Validations personnalisées

Pour les règles qui dépassent les validateurs intégrés, écrivez une méthode et enregistrez-la avec validate. Ajoutez les problèmes via errors.add.

class User < ApplicationRecord
  validate :name_not_admin

  def name_not_admin
    if name == "admin"
      errors.add(:name, "cannot be admin")
    end
  end
end

Interroger avec where

L'interface de requête commence avec where, qui filtre les lignes. Elle renvoie une relation à évaluation différée que vous pouvez encore chaîner avant son exécution dans la base de données.

User.where(active: true)
User.where("age > ?", 18)
User.where(role: ["admin", "editor"])

Trier et limiter

Structurez les résultats avec des méthodes chaînables :

order(created_at: :desc) effectue le tri.
limit(10) et offset(20) effectuent la pagination.
select(:id, :name) sélectionne les colonnes.

User.where(active: true)
    .order(created_at: :desc)
    .limit(10)

Agrégats et chargement différé

Les assistants d'agrégation exécutent des fonctions de la base de données : count, sum(:amount), average(:age), maximum, minimum. Les relations sont différées ; la requête s'exécute uniquement lorsque vous les parcourez, appelez un agrégat ou utilisez to_a.

User.where(active: true).count
Order.sum(:total)
User.average(:age)

Portées

Une portée nomme une requête réutilisable afin que vous puissiez la composer proprement. Les portées renvoient des relations et peuvent être chaînées entre elles ainsi qu'avec where.

class User < ApplicationRecord
  scope :active, -> { where(active: true) }
  scope :adults, -> { where("age >= ?", 18) }
end

User.active.adults

Vérification rapide

Vérifiez votre compréhension des validations et des requêtes.

Récapitulatif : validations et requêtes

Vous avez appris à protéger et à récupérer des données :

Les validations de présence, d'unicité, de longueur et de format protègent les enregistrements.
valid? et errors signalent les problèmes ; save! lève une exception.
Les validations personnalisées couvrent les règles particulières.
where, order, limit, les agrégats et les portées construisent des requêtes différées.

Le cours sur les modèles et Active Record est maintenant terminé.

Questions Fréquemment Posées

La leçon « Validations et requêtes » est-elle gratuite ?

Oui — le texte complet de « Validations et requêtes » 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 « Validations et requêtes » ?

Intégrité et interrogation des données 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 « Validations et requêtes » ?

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