Ruby Academy · Lezione

Validazioni e query

Integrità e interrogazione dei dati

Validazioni e query è una lezione Ruby Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Ruby Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Ruby Academy include 4 lezioni in totale.

Perché usare le validazioni?

Le validazioni proteggono i dati prima che raggiungano il database. Vengono eseguite quando si salva un record e rifiutano i dati non validi con messaggi utili.

Impediscono l'inserimento di dati errati (nomi mancanti, indirizzi email malformati).
Vengono eseguite in Ruby, quindi è facile mostrare i messaggi agli utenti.
Completano i vincoli del database, ma non li sostituiscono.

Validazione della presenza

La regola più comune è validates :field, presence: true, che richiede un valore non vuoto. Il salvataggio senza questo valore fallisce e registra un errore.

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

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

Validazione dell'unicità

uniqueness: true impedisce i valori duplicati, ad esempio due utenti con lo stesso indirizzo email. La abbini a un indice univoco del database, perché la validazione da sola presenta una race condition in presenza di forte concorrenza.

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

Formato e lunghezza

Altri validatori integrati:

length: { minimum: 8 } per i limiti di lunghezza.
format: { with: /regex/ } per i pattern.
numericality: true per i numeri.
inclusion: { in: [...] } per i valori consentiti.

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

valid? e errors

Chiami valid? per eseguire le validazioni senza salvare. Dopo un salvataggio non riuscito, record.errors contiene i problemi e errors.full_messages fornisce stringhe leggibili per l'interfaccia utente.

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

save vs save!

Due modalità di salvataggio:

save restituisce true/false, quindi può usare il risultato per scegliere il ramo da eseguire.
save! solleva RecordInvalid in caso di errore, utile quando i dati non validi devono generare un'eccezione.

Lo stesso schema si applica a create/create! e update/update!.

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

Validazioni personalizzate

Per le regole che vanno oltre i validatori integrati, definisca un metodo e lo registri con validate. Aggiunga i problemi tramite 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

Interrogazioni con where

L'interfaccia delle query inizia con where, che filtra le righe. Restituisce una relazione lazy che può concatenare con altre operazioni prima che venga eseguita sul database.

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

Ordinamento e limite

Dia forma ai risultati con metodi concatenabili:

order(created_at: :desc) ordina i risultati.
limit(10) e offset(20) consentono la paginazione.
select(:id, :name) seleziona le colonne.

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

Aggregazioni e caricamento lazy

Gli helper per le aggregazioni eseguono funzioni del database: count, sum(:amount), average(:age), maximum, minimum. Le relazioni sono lazy; la query viene eseguita solo quando si enumerano i risultati, si chiama un'aggregazione o si usa to_a.

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

Scope

Uno scope assegna un nome a una query riutilizzabile, così può comporla in modo ordinato. Gli scope restituiscono relazioni e si concatenano tra loro e con where.

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

User.active.adults

Controllo rapido

Verifichi la sua comprensione delle validazioni e delle query.

Riepilogo: validazioni e query

Ha imparato a proteggere e recuperare i dati:

Le validazioni come presenza, unicità, lunghezza e formato proteggono i salvataggi.
valid? ed errors segnalano i problemi; save! solleva un'eccezione.
Le validazioni personalizzate gestiscono regole specifiche.
where, order, limit, le aggregazioni e gli scope compongono query lazy.

In questo modo completa il corso Models and Active Record.

Domande Frequenti

La lezione «Validazioni e query» è gratuita?

Sì — il testo completo di «Validazioni e query» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Ruby Academy, passa a CoddyKit PRO. Il corso Ruby Academy include 4 lezioni in totale.

Cosa imparerò in «Validazioni e query»?

Integrità e interrogazione dei dati Eserciti Ruby Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Ruby Academy?

Non è richiesta alcuna esperienza precedente. Ruby Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Validazioni e query»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Ruby Academy?

Sì. Ogni lezione Ruby Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Ruby Academy