Railsドキュメント(v6.0.2.1)

validates_uniqueness_of(フィールド名 [, オプション])

validates_uniqueness_of :user_name, scope: :account_id

validates_associated(バリデーション対象 [, ...])

class Book < ActiveRecord::Base
  has_many :pages
  belongs_to :library
  validates_associated :pages, :library
end

validates(フィールド名, 種類 [, オプション])

validates :form, acceptance: true

validates :form, acceptance: false

validates :email, confirmation: true

validates :email, confirmation: false

validates :subdomain, exclusion: {in: %w(www us ca jp)}

validates :legacy_code, format: {with: /\A[a-zA-Z]+\z/}

validates :size, inclusion: {in: %w(small medium large)}

validates :name, length: {minimum: 2}

validates :points, numericality: true

validates :name, :login, :email, presence: true

validates :name, :login, :email, absence: true

validates :email, uniqueness: true

validates_presence_of(バリデーション対象 [, ...])

validates_presence_of :first_name

validate(バリデーションメソッド名 [, ...])

class Comment
  include ActiveModel::Validations

  validate :must_be_friends

  def must_be_friends
    errors.add(:base, 'Must be friends to leave a comment') unless commenter.friend_of?(commentee)
  end
end

class Comment
  include ActiveModel::Validations

  validate do |comment|
    comment.must_be_friends
  end

  def must_be_friends
    errors.add(:base, 'Must be friends to leave a comment') unless commenter.friend_of?(commentee)
  end
end

validates_absence_of(フィールド名 [, ...])

class Person < ActiveRecord::Base
  validates_acceptance_of :terms_of_service
  validates_acceptance_of :eula, message: 'must be abided'
end

validates_acceptance_of(フィールド名 [, ...])

class Person < ActiveRecord::Base
  validates_acceptance_of :terms_of_service
  validates_acceptance_of :eula, message: 'must be abided'
end

validates_confirmation_of(フィールド名 [, ...])

  validates_confirmation_of :user_name, :password

validates_exclusion_of(フィールド名 [, ...])

class Person < ActiveRecord::Base
  validates_exclusion_of :username, in: %w( admin superuser ), message: "You don't belong here"
  validates_exclusion_of :age, in: 30..60, message: 'This site is only for under 30 and over 60'
  validates_exclusion_of :format, in: %w( mov avi ), message: "extension %{value} is not allowed"
  validates_exclusion_of :password, in: ->(person) { [person.username, person.first_name] },
                         message: 'should not be the same as your username or first name'
  validates_exclusion_of :karma, in: :reserved_karmas
end

validates_format_of(フィールド名 [, ...])

validates_format_of :email, with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/, on: :create

validates_inclusion_of(フィールド名 [, ...])

class Person < ActiveRecord::Base
  validates_inclusion_of :gender, in: %w( m f )
  validates_inclusion_of :age, in: 0..99
  validates_inclusion_of :format, in: %w( jpg gif png ), message: "extension %{value} is not included in the list"
  validates_inclusion_of :states, in: ->(person) { STATES[person.country] }
  validates_inclusion_of :karma, in: :available_karmas
end

validates_length_of(するフィールド名 [, ...])

class Person < ActiveRecord::Base
  validates_length_of :first_name, maximum: 30
  validates_length_of :last_name, maximum: 30, message: "less than 30 if you don't mind"
  validates_length_of :fax, in: 7..32, allow_nil: true
  validates_length_of :phone, in: 7..32, allow_blank: true
  validates_length_of :user_name, within: 6..20, too_long: 'pick a shorter name', too_short: 'pick a longer name'
  validates_length_of :zip_code, minimum: 5, too_short: 'please enter at least 5 characters'
  validates_length_of :smurf_leader, is: 4, message: "papa is spelled with 4 characters... don't play me."
  validates_length_of :essay, minimum: 100, too_short: 'Your essay must be at least 100 words.',
                      tokenizer: ->(str) { str.scan(/\w+/) }
end

validates_numericality_of(フィールド名 [, ...])

validates_numericality_of :value, on: :create

validates_with(引数)

validates_with MyValidator

validates_each(キー名, [,  オプション])

validates_each :first_name, :last_name, allow_blank: true do |record, attr, value|
  record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z
end