Ruby on Rails
ActiveRecord-validaties

Getalidatie van een kenmerk valideren

Deze validatie beperkt het invoegen van alleen numerieke waarden.

class Player < ApplicationRecord
  validates :points, numericality: true
  validates :games_played, numericality: { only_integer: true }
end

Bovendien :only_integer , accepteert deze helper ook de volgende opties om beperkingen toe te voegen aan acceptabele waarden:

• :greater_than - Geeft aan dat de waarde groter moet zijn dan de opgegeven waarde. Het standaardfoutbericht voor deze optie is "moet groter zijn dan% {count}".
• :greater_than_or_equal_to - Geeft aan dat de waarde groter dan of gelijk moet zijn aan de opgegeven waarde. Het standaardfoutbericht voor deze optie is "moet groter zijn dan of gelijk zijn aan% {count}".
• :equal_to - Geeft aan dat de waarde gelijk moet zijn aan de opgegeven waarde. Het standaardfoutbericht voor deze optie is "moet gelijk zijn aan% {count}".
• :less_than - Geeft aan dat de waarde kleiner moet zijn dan de opgegeven waarde. Het standaardfoutbericht voor deze optie is "moet kleiner zijn dan% {count}".
• :less_than_or_equal_to - Geeft aan dat de waarde kleiner dan of gelijk aan de opgegeven waarde moet zijn. Het standaardfoutbericht voor deze optie is "moet kleiner zijn dan of gelijk zijn aan% {count}".
• :other_than - Geeft aan dat de waarde anders moet zijn dan de opgegeven waarde. Het standaardfoutbericht voor deze optie is "moet anders zijn dan% {count}".
• :odd - Geeft aan dat de waarde een oneven getal moet zijn, indien ingesteld op waar. Het standaardfoutbericht voor deze optie is "moet oneven zijn".
• :even - Geeft aan dat de waarde een even getal moet zijn als deze is ingesteld op true. Het standaardfoutbericht voor deze optie is "moet even zijn".

Numerieke waarden staan standaard geen nulwaarden toe. U kunt allow_nil: true gebruiken om dit toe te staan.

Valideer het unieke karakter van een attribuut

Deze helper valideert dat de waarde van het kenmerk uniek is vlak voordat het object wordt opgeslagen.

class Account < ApplicationRecord
  validates :email, uniqueness: true
end

Er is een :scope die u kunt gebruiken om een of meer kenmerken op te geven die worden gebruikt om de controle op uniekheid te beperken:

class Holiday < ApplicationRecord
  validates :name, uniqueness: { scope: :year,
    message: "should happen once per year" }
end

Er is ook een :case_sensitive optie die u kunt gebruiken om te bepalen of de uniciteitsbeperking hoofdlettergevoelig is of niet. Deze optie is standaard true .

class Person < ApplicationRecord
  validates :name, uniqueness: { case_sensitive: false }
end

De aanwezigheid van een kenmerk valideren

Deze helper valideert dat de opgegeven kenmerken niet leeg zijn.

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

Person.create(name: "John").valid? # => true
Person.create(name: nil).valid? # => false

U kunt de absence om te valideren dat de opgegeven kenmerken afwezig zijn. Gebruikt het het present? methode om te controleren op nul of lege waarden.

class Person < ApplicationRecord
  validates :name, :login, :email, absence: true
end

Opmerking: als het kenmerk een boolean is, kunt u geen gebruik maken van de gebruikelijke aanwezigheidsvalidatie (het kenmerk zou niet geldig zijn voor een false waarde). U kunt dit voor elkaar krijgen met behulp van een validatie voor opname:

validates :attribute, inclusion: [true, false]

Validaties overslaan

Gebruik de volgende methoden als u de validaties wilt overslaan. Met deze methoden wordt het object in de database opgeslagen, zelfs als het ongeldig is.

• decrement!
• decrement_counter
• increment!
• increment_counter
• toggle!
• tintje
• update alles
• update_attribute
• update_column
• update_columns
• update_counters

U kunt ook validatie over te slaan tijdens het opslaan door het passeren validate als een argument om save

User.save(validate: false)

De lengte van een kenmerk valideren

class Person < ApplicationRecord
  validates :name, length: { minimum: 2 }
  validates :bio, length: { maximum: 500 }
  validates :password, length: { in: 6..20 }
  validates :registration_number, length: { is: 6 }
end

De mogelijke opties voor lengtebeperking zijn:

• :minimum - Het kenmerk mag niet korter zijn dan de opgegeven lengte.
• :maximum - Het kenmerk kan niet meer dan de opgegeven lengte hebben.
• :in (of :within ) - De kenmerklengte moet in een bepaald interval worden opgenomen. De waarde voor deze optie moet een bereik zijn.
• :is - De attribuutlengte moet gelijk zijn aan de gegeven waarde.

Groepering validatie

Soms is het handig om meerdere validaties één voorwaarde te laten gebruiken. Het kan eenvoudig worden bereikt met behulp van with_options.

class User < ApplicationRecord
  with_options if: :is_admin? do |admin|
    admin.validates :password, length: { minimum: 10 }
    admin.validates :email, presence: true
  end
end

Alle validaties binnen het with_options-blok hebben automatisch de voorwaarde doorstaan als:: is_admin?

Aangepaste validaties

U kunt uw eigen validaties toevoegen door nieuwe klassen toe te voegen die erven van ActiveModel::Validator of van ActiveModel::EachValidator . Beide methoden zijn vergelijkbaar, maar ze werken op een iets andere manier:

ActiveModel::Validator en validates_with

Implementeer de validate die een record als argument neemt en de validatie daarop uitvoert. Gebruik vervolgens validates_with met de klasse op het model.

# app/validators/starts_with_a_validator.rb
class StartsWithAValidator < ActiveModel::Validator
  def validate(record)
    unless record.name.starts_with? 'A'
      record.errors[:name] << 'Need a name starting with A please!'
    end
  end
end
 
class Person < ApplicationRecord
  validates_with StartsWithAValidator
end

ActiveModel::EachValidator en validate

Als u uw nieuwe validator liever met de algemene validate op een enkele parameter gebruikt, maakt u een klasse die ActiveModel::EachValidator van ActiveModel::EachValidator en implementeert u de methode validate_each waarvoor drie argumenten nodig zijn: record , attribute en value :

class EmailValidator < ActiveModel::EachValidator
  def validate_each(record, attribute, value)
    unless value =~ /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i
      record.errors[attribute] << (options[:message] || 'is not an email')
    end
  end
end
 
class Person < ApplicationRecord
  validates :email, presence: true, email: true
end

Meer informatie over de Rails-gidsen .

Valideert de indeling van een kenmerk

Valideren dat de waarde van een attribuut overeenkomt met een reguliere expressie met behulp van format en with optie.

class User < ApplicationRecord
  validates :name, format: { with: /\A\w{6,10}\z/ }
end

U kunt ook een constante definiëren en de waarde ervan instellen op een reguliere expressie en deze doorgeven aan de optie with: Dit is wellicht handiger voor echt complexe reguliere expressies

PHONE_REGEX = /\A\(\d{3}\)\d{3}-\d{4}\z/
validates :phone, format: { with: PHONE_REGEX }

Het standaardfoutbericht is invalid . Dit kan worden gewijzigd met de optie :message .

validates :bio, format: { with: /\A\D+\z/, message: "Numbers are not allowed" }

Het omgekeerde antwoordt ook en u kunt opgeven dat een waarde niet moet overeenkomen met een reguliere expressie met de optie without:

Valideert opname van een attribuut

U kunt controleren of een waarde is opgenomen in een array met behulp van de inclusion: helper. De :in optie en zijn alias,: :within tonen de set acceptabele waarden.

class Country < ApplicationRecord
  validates :continent, inclusion: { in: %w(Africa Antartica Asia Australia
                                            Europe North America South America) }
end

Gebruik de exclusion: helper om te controleren of een waarde niet in een array is opgenomen

class User < ApplicationRecord
  validates :name, exclusion: { in: %w(admin administrator owner) }
end

Voorwaardelijke validatie

Soms moet u het record mogelijk alleen onder bepaalde voorwaarden valideren.

class User < ApplicationRecord
  validates :name, presence: true, if: :admin? 

  def admin?
    conditional here that returns boolean value
  end
end

Als je conditioneel erg klein is, kun je een Proc gebruiken:

class User < ApplicationRecord
  validates :first_name, presence: true, if: Proc.new { |user| user.last_name.blank? }
end

Voor negatieve voorwaardelijke voorwaarden kunt u gebruiken unless :

class User < ApplicationRecord
  validates :first_name, presence: true, unless: Proc.new { |user| user.last_name.present? }
end

Je kunt ook een string doorgeven, die zal worden uitgevoerd via instance_eval :

class User < ApplicationRecord
  validates :first_name, presence: true, if: 'last_name.blank?'
end

Bevestiging van kenmerk

U moet dit gebruiken wanneer u twee tekstvelden hebt die exact dezelfde inhoud moeten ontvangen. U wilt bijvoorbeeld een e-mailadres of een wachtwoord bevestigen. Met deze validatie wordt een virtueel kenmerk gemaakt waarvan de naam de naam is van het veld dat moet worden bevestigd met bijgevoegde _confirmation .

class Person < ApplicationRecord
  validates :email, confirmation: true
end

Opmerking Deze controle wordt alleen uitgevoerd als email_confirmation niet nul is.

Om bevestiging te vereisen, moet u een aanwezigheidscontrole voor het bevestigingskenmerk toevoegen.

class Person < ApplicationRecord
  validates :email,      confirmation: true
  validates :email_confirmation, presence: true
end

Bron

Gebruik: op optie

Met de optie :on kunt u opgeven wanneer de validatie moet plaatsvinden. Het standaardgedrag voor alle ingebouwde validatiehelpers moet worden uitgevoerd bij opslaan (zowel wanneer u een nieuw record maakt als wanneer u het bijwerkt).

class Person < ApplicationRecord
  # it will be possible to update email with a duplicated value
  validates :email, uniqueness: true, on: :create
 
  # it will be possible to create the record with a non-numerical age
  validates :age, numericality: true, on: :update
 
  # the default (validates on both create and update)
  validates :name, presence: true
end