Ruby on Rails
ActiveRecord मान्यताओं

किसी विशेषता की संख्यात्मकता को मान्य करना

यह सत्यापन केवल संख्यात्मक मानों के सम्मिलन को प्रतिबंधित करता है।

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

इसके अलावा :only_integer , यह सहायक स्वीकार्य मानों में बाधाओं को जोड़ने के लिए निम्नलिखित विकल्पों को भी स्वीकार करता है:

• :greater_than अधिक से :greater_than - निर्दिष्ट करता है कि मूल्य आपूर्ति मूल्य से अधिक होना चाहिए। इस विकल्प के लिए डिफ़ॉल्ट त्रुटि संदेश "% {काउंट} से अधिक होना चाहिए"।
• :greater_than_or_equal_to अधिक से :greater_than_or_equal_to - निर्दिष्ट करता है कि मान आपूर्ति मूल्य से अधिक या उसके बराबर होना चाहिए। इस विकल्प के लिए डिफ़ॉल्ट त्रुटि संदेश "% {काउंट} से अधिक या बराबर होना चाहिए"।
• :equal_to - निर्दिष्ट करता है कि मूल्य आपूर्ति किए गए मूल्य के बराबर होना चाहिए। इस विकल्प के लिए डिफ़ॉल्ट त्रुटि संदेश "% {काउंट} के बराबर होना चाहिए" है।
• :less_than - निर्दिष्ट करता है कि मूल्य को दिए गए मूल्य से कम होना चाहिए। इस विकल्प के लिए डिफ़ॉल्ट त्रुटि संदेश "% {काउंट} से कम होना चाहिए" है।
• :less_than_or_equal_to - निर्दिष्ट करता है कि मान आपूर्ति किए गए मान से कम या बराबर होना चाहिए। इस विकल्प के लिए डिफ़ॉल्ट त्रुटि संदेश "% {काउंट} से कम या बराबर होना चाहिए"।
• :other_than - निर्दिष्ट करता है कि मान आपूर्ति किए गए मूल्य के अलावा अन्य होना चाहिए। इस विकल्प के लिए डिफ़ॉल्ट त्रुटि संदेश "% {काउंट} से इतर होना चाहिए" है।
• :odd - निर्दिष्ट करता है कि मान एक विषम संख्या होना चाहिए यदि सही पर सेट किया गया है। इस विकल्प के लिए डिफ़ॉल्ट त्रुटि संदेश "विषम होना चाहिए" है।
• :even - निर्दिष्ट करता है कि मान एक सम संख्या होना चाहिए यदि सही पर सेट किया गया है। इस विकल्प के लिए डिफ़ॉल्ट त्रुटि संदेश "यहां तक कि होना चाहिए" है।

डिफ़ॉल्ट रूप से, संख्यात्मकता शून्य मानों की अनुमति नहीं देती है। आप अनुमति देने के लिए allow_nil: true विकल्प का उपयोग कर सकते हैं।

एक विशेषता की विशिष्ट विशिष्टता

यह सहायक मान्य करता है कि ऑब्जेक्ट के सहेजे जाने से पहले विशेषता का मान अद्वितीय सही है।

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

एक :scope विकल्प है जिसका उपयोग आप एक या अधिक विशेषताओं को निर्दिष्ट करने के लिए कर सकते हैं जिनका उपयोग विशिष्टता की जांच को सीमित करने के लिए किया जाता है:

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

वहाँ भी है :case_sensitive विकल्प जिसका उपयोग आप यह परिभाषित करने के लिए कर सकते हैं कि विशिष्टता की बाधा मामला संवेदनशील होगा या नहीं। यह विकल्प true लिए चूकता true ।

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

किसी विशेषता की उपस्थिति की पुष्टि करना

यह सहायक पुष्टि करता है कि निर्दिष्ट विशेषताएँ खाली नहीं हैं।

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

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

आप absence सहायक का उपयोग यह प्रमाणित करने के लिए कर सकते हैं कि निर्दिष्ट विशेषताएँ अनुपस्थित हैं। यह present? का उपयोग करता है present? शून्य या खाली मानों की जाँच करने की विधि।

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

ध्यान दें: यदि विशेषता एक boolean है, तो आप सामान्य उपस्थिति सत्यापन का उपयोग नहीं कर सकते हैं (विशेषता false मान के लिए मान्य नहीं होगी)। आप इसे एक समावेशन सत्यापन का उपयोग करके प्राप्त कर सकते हैं:

validates :attribute, inclusion: [true, false]

लंघन मान्यताओं

मान्यताओं को छोड़ना चाहते हैं, तो निम्न विधियों का उपयोग करें। ये विधियाँ डेटाबेस को अमान्य होने पर भी सहेजेगी।

• घटती!
• decrement_counter
• वेतन वृद्धि!
• increment_counter
• टॉगल!
• स्पर्श
• सब अद्यतित
• update_attribute
• update_column
• update_columns
• update_counters

तुम भी सत्यापन छोड़ कर सकते हैं पारित करके सहेजने के दौरान validate एक तर्क के रूप में save

User.save(validate: false)

एक विशेषता की वैधता लंबाई

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

संभावित लंबाई बाधा विकल्प हैं:

• :minimum - विशेषता निर्दिष्ट लंबाई से कम नहीं हो सकती।
• :maximum - विशेषता निर्दिष्ट लंबाई से अधिक नहीं हो सकती।
• :in (या :within ) - विशेषता लंबाई को एक निश्चित अंतराल में शामिल किया जाना चाहिए। इस विकल्प के लिए मूल्य एक सीमा होनी चाहिए।
• :is - विशेषता लंबाई दी गई मान के बराबर होनी चाहिए।

सत्यापन को समूहीकृत करना

कभी-कभी यह उपयोगी होता है कि कई सत्यापन एक शर्त का उपयोग करें। इसे आसानी से 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

With_options ब्लॉक के अंदर सभी सत्यापन स्वचालित रूप से इस शर्त को पारित कर देंगे यदि:: is_admin?

कस्टम सत्यापन

आप ActiveModel::Validator या ActiveModel::Validator से विरासत में मिली नई कक्षाओं को जोड़कर अपनी ActiveModel::EachValidator । दोनों विधियां समान हैं लेकिन वे कुछ अलग तरीके से काम करती हैं:

ActiveModel::Validator और validates_with

validate विधि को लागू करें जो एक तर्क के रूप में रिकॉर्ड लेता है और उस पर सत्यापन करता है। फिर मॉडल पर वर्ग के साथ validates_with उपयोग करें।

# 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 और validate

आप आम का उपयोग कर अपने नए सत्यापनकर्ता का उपयोग करना पसंद करते हैं validate एक भी परम पर विधि, एक वर्ग से इनहेरिट बनाने ActiveModel::EachValidator और लागू validate_each तरीका है जिसके तीन तथ्य होते हैं: record , attribute , और 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

रेल गाइड पर अधिक जानकारी।

किसी विशेषता का प्रारूप मान्य करता है

पुष्टि करें कि एक विशेषता का मान format और विकल्प के with एक नियमित अभिव्यक्ति से मेल खाता है।

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

आप एक निरंतर को भी परिभाषित कर सकते हैं और इसके मूल्य को एक नियमित अभिव्यक्ति पर सेट कर सकते हैं और इसे इसके with: पास कर सकते हैं with: विकल्प। यह वास्तव में जटिल नियमित अभिव्यक्तियों के लिए अधिक सुविधाजनक हो सकता है

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

डिफ़ॉल्ट त्रुटि संदेश is invalid । इसे :message विकल्प के साथ बदला जा सकता है।

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

रिवर्स भी जवाब देता है, और आप यह निर्दिष्ट कर सकते हैं कि मान without: विकल्प के साथ एक नियमित अभिव्यक्ति से मेल नहीं खाना चाहिए

एक विशेषता को शामिल करने की पुष्टि करता है

आप जाँच कर सकते हैं कि क्या मान शामिल करने वाले किसी सरणी में inclusion: सहायक। :in विकल्प और उसके उर्फ, :within स्वीकार्य मानों में से समूह दिखाते हैं।

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

यह जाँचने के लिए कि क्या मान किसी सरणी में शामिल नहीं है, exclusion: उपयोग करें exclusion: सहायक

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

सशर्त मान्यता है

कभी-कभी आपको केवल कुछ शर्तों के तहत रिकॉर्ड को मान्य करने की आवश्यकता हो सकती है।

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

  def admin?
    conditional here that returns boolean value
  end
end

यदि आप सशर्त बहुत छोटा है, तो आप एक प्रोक का उपयोग कर सकते हैं:

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

unless आप उपयोग unless कर सकते नकारात्मक स्थिति के लिए:

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

तुम भी एक स्ट्रिंग है, जो के माध्यम से क्रियान्वित की जाएगी पारित कर सकते हैं instance_eval :

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

विशेषता की पुष्टि

आपको इसका उपयोग तब करना चाहिए जब आपके पास दो पाठ फ़ील्ड हों जो समान सामग्री प्राप्त करें। उदाहरण के लिए, आप ईमेल पते या पासवर्ड की पुष्टि कर सकते हैं। यह सत्यापन एक वर्चुअल विशेषता बनाता है जिसका नाम उस फ़ील्ड का नाम है जिसकी पुष्टि की गई है _confirmation साथ।

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

नोट यह जाँच केवल तभी की email_confirmation है जब email_confirmation शून्य नहीं है।

पुष्टिकरण की आवश्यकता के लिए, पुष्टिकरण विशेषता के लिए उपस्थिति जाँच जोड़ना सुनिश्चित करें।

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

स्रोत

उपयोग: विकल्प पर

विकल्प :on आपको निर्दिष्ट करना चाहिए कि सत्यापन कब होना चाहिए। सभी अंतर्निहित सत्यापन सहायकों के लिए डिफ़ॉल्ट व्यवहार को सेव पर चलाया जाना है (दोनों जब आप एक नया रिकॉर्ड बना रहे हों और जब आप अपडेट कर रहे हों)।

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