Ruby on Rails
ActiveRecord-valideringar

Validera ett attributs numeralitet

Denna validering begränsar införandet av endast numeriska värden.

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

Förutom :only_integer denna hjälper också följande alternativ för att lägga till begränsningar till acceptabla värden:

• :greater_than - Anger att värdet måste vara större än det levererade värdet. Standardfelmeddelandet för det här alternativet är "måste vara större än% {count}".
• :greater_than_or_equal_to - Anger att värdet måste vara större än eller lika med det levererade värdet. Standardfelmeddelandet för detta alternativ är "måste vara större än eller lika med% {count}".
• :equal_to - Anger att värdet måste vara lika med det levererade värdet. Standardfelmeddelandet för detta alternativ är "måste vara lika med% {count}".
• :less_than - Anger att värdet måste vara mindre än det levererade värdet. Standardfelmeddelandet för detta alternativ är "måste vara mindre än% {count}".
• :less_than_or_equal_to - Anger att värdet måste vara mindre än eller lika med det levererade värdet. Standardfelmeddelandet för det här alternativet är "måste vara mindre än eller lika med% {count}".
• :other_than - Anger att värdet måste vara annat än det medföljande värdet. Standardfelmeddelandet för det här alternativet är "måste vara annat än% {count}".
• :odd - Anger att värdet måste vara ett udda tal om det är satt. Standardfelmeddelandet för det här alternativet är "måste vara udda".
• :even - Anger att värdet måste vara ett jämnt tal om det är satt. Standardfelmeddelandet för detta alternativ är "måste vara jämnt".

Som standard tillåter inte numeriska värden nollvärden. Du kan använda allow_nil: true-alternativet för att tillåta det.

Validera unika egenskaper hos ett attribut

Denna hjälper validerar att attributets värde är unikt precis innan objektet sparas.

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

Det finns ett :scope alternativ som du kan använda för att ange ett eller flera attribut som används för att begränsa unikhetskontrollen:

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

Det finns också ett alternativ :case_sensitive som du kan använda för att definiera om unikhetens begränsning är skiftlägeskänslig eller inte. Detta alternativ standard true .

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

Validera närvaron av ett attribut

Denna hjälper validerar att de angivna attributen inte är tomma.

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

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

Du kan använda absence att bekräfta att de angivna attributen saknas. Den använder present? metod för att kontrollera om inga eller tomma värden.

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

Obs: Om attributet är ett boolean kan du inte använda den vanliga närvarovalideringen (attributet är inte giltigt för ett false värde). Du kan göra detta genom att använda en inkluderingsvalidering:

validates :attribute, inclusion: [true, false]

Hoppa över valideringar

Använd följande metoder om du vill hoppa över valideringarna. Dessa metoder sparar objektet i databasen även om det är ogiltigt.

• minskning!
• decrement_counter
• ökning!
• increment_counter
• Växla!
• Rör
• uppdatera alla
• update_attribute
• update_column
• update_columns
• update_counters

Du kan också hoppa över validering medan du sparar genom att skicka validate som ett argument för att save

User.save(validate: false)

Validera längden på ett attribut

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 möjliga längdbegränsningsalternativen är:

• :minimum - Attributet kan inte ha mindre än den angivna längden.
• :maximum - Attributet kan inte ha mer än den angivna längden.
• :in (eller :within ) - Attributets längd måste inkluderas i ett givet intervall. Värdet för det här alternativet måste vara ett intervall.
• :is - Attributets längd måste vara lika med det angivna värdet.

Gruppera validering

Ibland är det användbart att flera valideringar använder ett villkor. Det kan enkelt uppnås med hjälp av_optioner.

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

Alla valideringar inuti with_options-blocket har automatiskt godkänt villkoret om:: is_admin?

Anpassade valideringar

Du kan lägga till dina egna valideringar och lägga till nya klasser som ärver från ActiveModel::Validator eller från ActiveModel::EachValidator . Båda metoderna är likadana men de fungerar på något olika sätt:

ActiveModel::Validator and validates_with

Implementera validate som tar en post som ett argument och utför valideringen på den. Använd sedan validates_with klassen på modellen.

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

Om du föredrar att använda din nya validator med hjälp av vanlig validate metoden på en enda parameter, skapa en klass ärver från ActiveModel::EachValidator och genomföra validate_each metod som tar tre argument: record , attribute och 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

Mer information om Rails-guiderna .

Validerar format för ett attribut

Bekräfta att ett attributs värde matchar ett vanligt uttryck med format och with alternativet.

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

Du kan också definiera en konstant och ställa in dess värde på ett reguljärt uttryck och skicka det till with: -alternativet. Detta kan vara mer praktiskt för riktigt komplexa reguljära uttryck

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

Standardfelmeddelandet är is invalid . Detta kan ändras med alternativet :message .

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

Svaren omvänt också, och du kan ange att ett värde inte ska matcha ett reguljärt uttryck med without: alternativ

Validerar inkludering av ett attribut

Du kan kontrollera om ett värde ingår i en matris med hjälp av inclusion: hjälpare. Den :in alternativ och dess alias, :within visar uppsättningen av acceptabla värden.

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

För att kontrollera om ett värde inte ingår i en matris använder du exclusion: hjälpare

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

Villkorlig validering

Ibland kan du behöva validera posten endast under vissa villkor.

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

  def admin?
    conditional here that returns boolean value
  end
end

Om du vill att det är riktigt litet kan du använda en Proc:

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

För negativ villkor kan du använda om unless :

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

Du kan också skicka en sträng som kommer att köras via instance_eval :

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

Bekräftelse av attribut

Du bör använda detta när du har två textfält som ska få exakt samma innehåll. Till exempel kanske du vill bekräfta en e-postadress eller ett lösenord. Denna validering skapar ett virtuellt attribut vars namn är namnet på fältet som måste bekräftas med _confirmation bifogad.

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

Obs! Denna kontroll utförs endast om email_confirmation inte är noll.

För att kräva bekräftelse, se till att lägga till en närvarokontroll för bekräftelseattributet.

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

Källa

Använd: på-alternativet

Alternativet :on låter dig ange när valideringen ska ske. Standardbeteendet för alla de inbyggda valideringshjälparna ska köras på spara (både när du skapar en ny post och när du uppdaterar den).

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