Ruby on Rails
ActiveRecord-Überprüfungen

Überprüfung der Numerizität eines Attributs

Diese Überprüfung beschränkt die Einfügung nur numerischer Werte.

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

Neben :only_integer akzeptiert dieser Helper auch die folgenden Optionen, um den akzeptablen Werten Einschränkungen hinzuzufügen:

• :greater_than - Gibt an, dass der Wert größer sein muss als der angegebene Wert. Die Standardfehlermeldung für diese Option lautet "muss größer als% {count} sein".
• :greater_than_or_equal_to - Gibt an, dass der Wert größer oder gleich dem angegebenen Wert sein muss. Die Standardfehlermeldung für diese Option lautet "muss größer oder gleich% {count} sein".
• :equal_to - Gibt an, dass der Wert dem angegebenen Wert entsprechen muss. Die Standardfehlermeldung für diese Option lautet "muss gleich% {count} sein".
• :less_than - Gibt an, dass der Wert unter dem angegebenen Wert liegen muss. Die Standardfehlermeldung für diese Option lautet "muss kleiner als% {count} sein".
• :less_than_or_equal_to - Gibt an, dass der Wert kleiner oder gleich dem angegebenen Wert sein muss. Die Standardfehlermeldung für diese Option lautet "muss kleiner oder gleich% {count} sein".
• :other_than - Gibt an, dass der Wert vom angegebenen Wert :other_than muss. Die Standardfehlermeldung für diese Option lautet "muss nicht% {count} sein".
• :odd - Gibt an, dass der Wert eine ungerade Zahl sein muss, wenn er auf true gesetzt ist. Die Standardfehlermeldung für diese Option lautet "Muss ungerade sein".
• :even - Gibt an, dass der Wert eine gerade Zahl sein muss, wenn er auf true gesetzt ist. Die Standardfehlermeldung für diese Option lautet "Muss gerade sein".

Standardmäßig erlaubt die Numerizität keine Nullwerte. Sie können die Option allow_nil: true verwenden, um dies zuzulassen.

Überprüfen Sie die Eindeutigkeit eines Attributs

Dieser Helfer überprüft, ob der Wert des Attributs eindeutig ist, bevor das Objekt gespeichert wird.

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

Es gibt eine Option :scope , mit der Sie ein oder mehrere Attribute angeben können, mit denen die Eindeutigkeitsprüfung eingeschränkt wird:

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

Es gibt auch eine Option :case_sensitive , mit der Sie festlegen können, ob die Eindeutigkeitseinschränkung die Groß- und Kleinschreibung :case_sensitive . Diese Option ist standardmäßig auf true .

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

Vorhandensein eines Attributs prüfen

Dieser Helfer überprüft, ob die angegebenen Attribute nicht leer sind.

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

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

Sie können die absence zu überprüfen, ob die angegebenen Attribute nicht vorhanden sind. Nutzt die present? Methode zum Überprüfen auf null oder leere Werte.

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

Hinweis: Wenn das Attribut ein boolean Attribut ist, können Sie die übliche Anwesenheitsüberprüfung nicht verwenden (das Attribut wäre für einen false Wert nicht gültig). Dies können Sie mit einer Inklusionsvalidierung erreichen:

validates :attribute, inclusion: [true, false]

Validierungen überspringen

Verwenden Sie die folgenden Methoden, wenn Sie die Validierungen überspringen möchten. Diese Methoden speichern das Objekt in der Datenbank, auch wenn es ungültig ist.

• dekrementieren!
• decrement_counter
• Zuwachs!
• increment_counter
• Umschalten!
• berühren
• Alle aktualisieren
• update_attribute
• update_column
• Update-Spalten
• Update_Counters

Sie können die Validierung beim Speichern auch überspringen, indem Sie validate als Argument zum save

User.save(validate: false)

Länge eines Attributs überprüfen

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

Die möglichen Längeneinschränkungsoptionen sind:

• :minimum - Das Attribut darf nicht kleiner als die angegebene Länge sein.
• :maximum - Das Attribut darf nicht länger als die angegebene Länge sein.
• :in (oder :within ) - Die Attributlänge muss in einem bestimmten Intervall enthalten sein. Der Wert für diese Option muss ein Bereich sein.
• :is - Die Attributlänge muss dem angegebenen Wert entsprechen.

Gruppierungsüberprüfung

In manchen Fällen ist es sinnvoll, dass mehrere Überprüfungen eine Bedingung verwenden. Dies kann leicht mit with_options erreicht werden.

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

Alle Validierungen im with_options-Block haben die Bedingung automatisch bestanden, wenn:: is_admin?

Benutzerdefinierte Validierungen

Sie können Ihre eigenen Validierungen hinzufügen, indem Sie neue Klassen hinzufügen, die von ActiveModel::Validator oder ActiveModel::EachValidator . Beide Methoden sind ähnlich, funktionieren jedoch auf etwas unterschiedliche Weise:

ActiveModel::Validator und validates_with

Implementieren Sie die validate Methode, die einen Datensatz als Argument verwendet und die Validierung daran ausführt. Verwenden Sie dann validates_with mit der Klasse im Modell.

# 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 und validate

Wenn Sie es vorziehen, Ihren neuen Prüfer mit der allgemeinen validate Methode für einen einzelnen Parameter zu verwenden, erstellen Sie eine Klasse, die ActiveModel::EachValidator und implementieren Sie die validate_each Methode, die drei Argumente verwendet: record , attribute und 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

Weitere Informationen zu den Rails-Führungen .

Überprüft das Format eines Attributs

Stellen Sie sicher, dass der Wert eines Attributs mit einem regulären Ausdruck übereinstimmt, und zwar mit format und der Option with .

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

Sie können auch eine Konstante definieren und ihren Wert auf einen regulären Ausdruck festlegen und an die Option with: . Dies kann für wirklich komplexe reguläre Ausdrücke bequemer sein

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

Die Standardfehlermeldung is invalid . Dies kann mit der :message Option geändert werden.

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

Die Umkehrung antwortet ebenfalls, und Sie können angeben, dass ein Wert mit der Option without: keinem regulären Ausdruck entsprechen sollte

Überprüft die Aufnahme eines Attributs

Sie können mit Hilfe des inclusion: einschließen inclusion: prüfen, ob ein Wert in einem Array enthalten ist. Die Option :in und ihr Alias :within zeigt die Menge der zulässigen Werte.

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

Um zu überprüfen, ob ein Wert nicht in einem Array enthalten ist, verwenden Sie den Helper exclusion:

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

Bedingte Validierung

In manchen Fällen müssen Sie die Aufzeichnung möglicherweise nur unter bestimmten Bedingungen überprüfen.

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

  def admin?
    conditional here that returns boolean value
  end
end

Wenn Ihre Bedingung sehr klein ist, können Sie ein Proc verwenden:

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

Für negative Bedingungen können Sie verwenden, es unless :

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

Sie können auch einen String übergeben, der über instance_eval ausgeführt wird:

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

Bestätigung des Attributs

Sie sollten dies verwenden, wenn Sie zwei Textfelder haben, die exakt denselben Inhalt erhalten sollen. Beispielsweise möchten Sie möglicherweise eine E-Mail-Adresse oder ein Passwort bestätigen. Bei dieser Überprüfung wird ein virtuelles Attribut erstellt, dessen Name dem Namen des Felds entspricht, das mit angehängter _confirmation bestätigt werden _confirmation .

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

Hinweis Diese Prüfung wird nur durchgeführt, wenn email_confirmation nicht gleich Null ist.

Um eine Bestätigung anzufordern, fügen Sie eine Präsenzprüfung für das Bestätigungsattribut hinzu.

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

Quelle

Verwendung: bei Option

Mit der Option :on können Sie angeben, wann die Überprüfung erfolgen soll. Das Standardverhalten für alle integrierten Validierungshelfer ist das Ausführen beim Speichern (sowohl beim Erstellen eines neuen Datensatzes als auch beim Aktualisieren).

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