ความทันสมัยในการตรวจสอบอีเมลสำหรับ Rails คืออะไร?

คุณใช้อะไรในการตรวจสอบที่อยู่อีเมลของผู้ใช้และเพราะเหตุใด

ฉันใช้validates_email_veracity_ofที่ค้นหาเซิร์ฟเวอร์ MX จริงๆ แต่นั่นเต็มไปด้วยความล้มเหลวด้วยเหตุผลหลายประการซึ่งส่วนใหญ่เกี่ยวข้องกับการรับส่งข้อมูลเครือข่ายและความน่าเชื่อถือ

ฉันมองไปรอบ ๆ และไม่พบสิ่งใดที่ชัดเจนว่ามีผู้คนจำนวนมากใช้ตรวจสอบความถูกต้องของที่อยู่อีเมล มีปลั๊กอินหรืออัญมณีที่ได้รับการบำรุงรักษาและถูกต้องตามสมควรหรือไม่?

PS: โปรดอย่าบอกให้ฉันส่งอีเมลพร้อมลิงก์เพื่อดูว่าอีเมลใช้งานได้หรือไม่ ฉันกำลังพัฒนาฟีเจอร์ "ส่งให้เพื่อน" จึงไม่สามารถใช้งานได้จริง

ด้วย Rails 3.0 คุณสามารถใช้การตรวจสอบอีเมลโดยไม่ต้อง regexp ใช้อัญมณีจดหมาย

นี่คือการใช้งานของฉัน ( บรรจุเป็นอัญมณี )

อย่าทำให้เรื่องนี้ยากกว่าที่ควรจะเป็น คุณลักษณะของคุณไม่สำคัญ การตรวจสอบความถูกต้องเป็นเพียงขั้นตอนพื้นฐานในการตรวจจับการพิมพ์ผิด ฉันจะทำมันด้วย regex ง่ายๆและไม่ต้องเสียวงจร CPU ไปกับอะไรที่ซับซ้อนเกินไป:

/\A[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]+\z/

ที่ดัดแปลงมาจากhttp://www.regular-expressions.info/email.html - ซึ่งคุณควรอ่านหากคุณต้องการทราบการแลกเปลี่ยนทั้งหมด หากคุณต้องการ regex ที่สอดคล้องกับ RFC822 ที่ถูกต้องและซับซ้อนมากขึ้นนั่นก็อยู่ในหน้านั้นเช่นกัน แต่สิ่งนี้คือคุณไม่จำเป็นต้องทำให้ถูกต้องทั้งหมด

หากที่อยู่ผ่านการตรวจสอบความถูกต้องคุณจะต้องส่งอีเมล หากอีเมลล้มเหลวคุณจะได้รับข้อความแสดงข้อผิดพลาด เมื่อถึงจุดใดที่คุณสามารถบอกผู้ใช้ว่า "ขออภัยเพื่อนของคุณไม่ได้รับสิ่งนั้นคุณต้องการลองอีกครั้งหรือไม่" หรือตั้งค่าสถานะเพื่อตรวจสอบด้วยตนเองหรือเพิกเฉยหรืออะไรก็ตาม

นี่คือตัวเลือกเดียวกับที่คุณต้องจัดการหากที่อยู่นั้นผ่านการตรวจสอบความถูกต้อง เนื่องจากแม้ว่าการตรวจสอบความถูกต้องของคุณจะสมบูรณ์แบบและคุณได้รับการพิสูจน์ที่สมบูรณ์ว่ามีที่อยู่ แต่การส่งอาจล้มเหลว

ค่าใช้จ่ายของผลบวกเท็จในการตรวจสอบความถูกต้องต่ำ ประโยชน์ของการตรวจสอบความถูกต้องที่ดีขึ้นก็ต่ำเช่นกัน ตรวจสอบความถูกต้องและกังวลเกี่ยวกับข้อผิดพลาดเมื่อเกิดขึ้น

ฉันสร้างอัญมณีสำหรับการตรวจสอบอีเมลใน Rails 3 ฉันค่อนข้างแปลกใจที่ Rails ไม่รวมสิ่งนี้ไว้เป็นค่าเริ่มต้น

http://github.com/balexand/email_validator

โครงการนี้ดูเหมือนจะมีผู้เฝ้าดูมากที่สุดใน github ในขณะนี้ (สำหรับการตรวจสอบอีเมลในราง):

https://github.com/alexdunae/validates_email_format_of

จากเอกสาร Rails 4 :

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 < ActiveRecord::Base
  validates :email, presence: true, email: true
end

ใน Rails 4 เพียงแค่เพิ่มvalidates :email, email:true(สมมติว่ามีการเรียกฟิลด์ของคุณemail) ลงในโมเดลของคุณแล้วเขียนง่าย ๆ (หรือซับซ้อน†)EmailValidatorเพื่อให้เหมาะกับความต้องการของคุณ

เช่น: - รุ่นของคุณ:

class TestUser
  include Mongoid::Document
  field :email,     type: String
  validates :email, email: true
end

ตัวตรวจสอบความถูกต้องของคุณ (เข้าไปapp/validators/email_validator.rb)

class EmailValidator < ActiveModel::EachValidator
  EMAIL_ADDRESS_QTEXT           = Regexp.new '[^\\x0d\\x22\\x5c\\x80-\\xff]', nil, 'n'
  EMAIL_ADDRESS_DTEXT           = Regexp.new '[^\\x0d\\x5b-\\x5d\\x80-\\xff]', nil, 'n'
  EMAIL_ADDRESS_ATOM            = Regexp.new '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+', nil, 'n'
  EMAIL_ADDRESS_QUOTED_PAIR     = Regexp.new '\\x5c[\\x00-\\x7f]', nil, 'n'
  EMAIL_ADDRESS_DOMAIN_LITERAL  = Regexp.new "\\x5b(?:#{EMAIL_ADDRESS_DTEXT}|#{EMAIL_ADDRESS_QUOTED_PAIR})*\\x5d", nil, 'n'
  EMAIL_ADDRESS_QUOTED_STRING   = Regexp.new "\\x22(?:#{EMAIL_ADDRESS_QTEXT}|#{EMAIL_ADDRESS_QUOTED_PAIR})*\\x22", nil, 'n'
  EMAIL_ADDRESS_DOMAIN_REF      = EMAIL_ADDRESS_ATOM
  EMAIL_ADDRESS_SUB_DOMAIN      = "(?:#{EMAIL_ADDRESS_DOMAIN_REF}|#{EMAIL_ADDRESS_DOMAIN_LITERAL})"
  EMAIL_ADDRESS_WORD            = "(?:#{EMAIL_ADDRESS_ATOM}|#{EMAIL_ADDRESS_QUOTED_STRING})"
  EMAIL_ADDRESS_DOMAIN          = "#{EMAIL_ADDRESS_SUB_DOMAIN}(?:\\x2e#{EMAIL_ADDRESS_SUB_DOMAIN})*"
  EMAIL_ADDRESS_LOCAL_PART      = "#{EMAIL_ADDRESS_WORD}(?:\\x2e#{EMAIL_ADDRESS_WORD})*"
  EMAIL_ADDRESS_SPEC            = "#{EMAIL_ADDRESS_LOCAL_PART}\\x40#{EMAIL_ADDRESS_DOMAIN}"
  EMAIL_ADDRESS_PATTERN         = Regexp.new "#{EMAIL_ADDRESS_SPEC}", nil, 'n'
  EMAIL_ADDRESS_EXACT_PATTERN   = Regexp.new "\\A#{EMAIL_ADDRESS_SPEC}\\z", nil, 'n'

  def validate_each(record, attribute, value)
    unless value =~ EMAIL_ADDRESS_EXACT_PATTERN
      record.errors[attribute] << (options[:message] || 'is not a valid email')
    end
  end
end

วิธีนี้จะอนุญาตอีเมลที่ถูกต้องทุกประเภทรวมถึงแท็กอีเมลที่เช่น "test+no_really@test.tes" เป็นต้น

เพื่อทดสอบสิ่งนี้ด้วยrspecในไฟล์spec/validators/email_validator_spec.rb

require 'spec_helper'

describe "EmailValidator" do
  let(:validator) { EmailValidator.new({attributes: [:email]}) }
  let(:model) { double('model') }

  before :each do
    model.stub("errors").and_return([])
    model.errors.stub('[]').and_return({})  
    model.errors[].stub('<<')
  end

  context "given an invalid email address" do
    let(:invalid_email) { 'test test tes' }
    it "is rejected as invalid" do
      model.errors[].should_receive('<<')
      validator.validate_each(model, "email", invalid_email)
    end  
  end

  context "given a simple valid address" do
    let(:valid_simple_email) { 'test@test.tes' }
    it "is accepted as valid" do
      model.errors[].should_not_receive('<<')    
      validator.validate_each(model, "email", valid_simple_email)
    end
  end

  context "given a valid tagged address" do
    let(:valid_tagged_email) { 'test+thingo@test.tes' }
    it "is accepted as valid" do
      model.errors[].should_not_receive('<<')    
      validator.validate_each(model, "email", valid_tagged_email)
    end
  end
end

นี่คือวิธีที่ฉันทำไปแล้ว YMMV

†การแสดงออกปกติเหมือนความรุนแรง หากไม่ได้ผลคุณใช้ไม่เพียงพอ

ตามที่Hallelujahแนะนำฉันคิดว่าการใช้Mail gemเป็นแนวทางที่ดี อย่างไรก็ตามฉันไม่ชอบห่วงบางอย่างที่นั่น

ฉันใช้:

def self.is_valid?(email) 

  parser = Mail::RFC2822Parser.new
  parser.root = :addr_spec
  result = parser.parse(email)

  # Don't allow for a TLD by itself list (sam@localhost)
  # The Grammar is: (local_part "@" domain) / local_part ... discard latter
  result && 
     result.respond_to?(:domain) && 
     result.domain.dot_atom_text.elements.size > 1
end

คุณอาจเข้มงวดขึ้นโดยเรียกร้องให้ TLDs (โดเมนระดับบนสุด) อยู่ในรายการนี้อย่างไรก็ตามคุณจะถูกบังคับให้อัปเดตรายการนั้นเมื่อ TLD ใหม่ปรากฏขึ้น (เช่นการเพิ่มปี 2012 .mobiและ.tel )

ข้อดีของการเชื่อมต่อโปรแกรมแยกวิเคราะห์โดยตรงก็คือกฎในไวยากรณ์ของเมลนั้นค่อนข้างกว้างสำหรับส่วนที่เมลเจ็มใช้ซึ่งได้รับการออกแบบมาเพื่อให้สามารถแยกวิเคราะห์ที่อยู่user<user@example.com>ซึ่งเป็นเรื่องปกติสำหรับ SMTP โดยการบริโภคจากMail::Addressคุณจะถูกบังคับให้ทำการตรวจสอบเพิ่มเติม

หมายเหตุอีกประการเกี่ยวกับ Mail gem แม้ว่าคลาสจะเรียกว่า RFC2822 ไวยากรณ์ก็มีองค์ประกอบบางอย่างของRFC5322เช่นการทดสอบนี้

ใน Rails 3 เป็นไปได้ที่จะเขียนตัวตรวจสอบที่ใช้ซ้ำได้ดังที่โพสต์ที่ยอดเยี่ยมนี้อธิบาย:

http://archives.ryandaigle.com/articles/2009/8/11/what-s-new-in-edge-rails-independent-model-validators

class EmailValidator < ActiveRecord::Validator   
  def validate()
    record.errors[:email] << "is not valid" unless
    record.email =~ /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i   
  end
end

และใช้กับvalidates_with:

class User < ActiveRecord::Base   
  validates_with EmailValidator
end

เมื่อสังเกตคำตอบอื่น ๆ คำถามก็ยังคงอยู่ - ทำไมต้องกังวลกับเรื่องนี้?

ปริมาณจริงของ edge case ที่ regex จำนวนมากอาจปฏิเสธหรือพลาดดูเหมือนเป็นปัญหา

ฉันคิดว่าคำถามคือ 'ฉันกำลังพยายามทำอะไรอยู่' แม้ว่าคุณจะ 'ตรวจสอบ' ที่อยู่อีเมล แต่คุณก็ไม่ได้ตรวจสอบความถูกต้องว่าเป็นที่อยู่อีเมลที่ใช้งานได้จริง

หากคุณใช้ regexp เพียงตรวจสอบว่ามี @ ที่ฝั่งไคลเอ็นต์หรือไม่

สำหรับสถานการณ์อีเมลที่ไม่ถูกต้องมีสาขา 'ข้อความล้มเหลวในการส่ง' ไปยังรหัสของคุณ

โดยทั่วไปมี 3 ตัวเลือกที่พบบ่อยที่สุด:

1. Regexp (ไม่มี regexp ที่อยู่อีเมลที่ใช้งานได้สำหรับทุกคนดังนั้นควรม้วนของคุณเอง)
2. แบบสอบถาม MX (นั่นคือสิ่งที่คุณใช้)
3. การสร้างโทเค็นการเปิดใช้งานและส่งทางไปรษณีย์ (วิธี restful_authentication)

หากคุณไม่ต้องการใช้ทั้ง validates_email_veracity_of และการสร้างโทเค็นฉันจะใช้การตรวจสอบ regexp ของโรงเรียนเก่า

อัญมณีจดหมายมีตัวแยกวิเคราะห์ที่อยู่ในตัว

begin
  Mail::Address.new(email)
  #valid
rescue Mail::Field::ParseError => e
  #invalid
end

โซลูชันนี้อ้างอิงจากคำตอบของ @SFEley และ @Alessandro DS พร้อมตัวอ้างอิงและคำชี้แจงการใช้งาน

คุณสามารถใช้คลาส validator นี้ในโมเดลของคุณได้ดังนี้:

class MyModel < ActiveRecord::Base
  # ...
  validates :colum, :email => { :allow_nil => true, :message => 'O hai Mark!' }
  # ...
end

ให้คุณมีสิ่งต่อไปนี้ในapp/validatorsโฟลเดอร์ของคุณ(Rails 3):

class EmailValidator < ActiveModel::EachValidator

  def validate_each(record, attribute, value)
    return options[:allow_nil] == true if value.nil?

    unless matches?(value)
      record.errors[attribute] << (options[:message] || 'must be a valid email address')
    end
  end

  def matches?(value)
    return false unless value

    if /\A[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]+\z/.match(value).nil?
      false
    else
      true
    end

  end
end

สำหรับรายชื่อผู้รับจดหมายตรวจสอบ (ฉันใช้ Rails 4.1.6)

ฉันได้ regexp จากที่นี่ที่นี่ดูเหมือนว่าจะสมบูรณ์มากและได้รับการทดสอบกับชุดค่าผสมจำนวนมาก คุณสามารถดูผลลัพธ์ในหน้านั้น

ฉันเปลี่ยนเป็น Ruby regexp เล็กน้อยและใส่ไว้ในไฟล์ lib/validators/email_list_validator.rb

นี่คือรหัส:

require 'mail'

class EmailListValidator < ActiveModel::EachValidator

  # Regexp source: https://fightingforalostcause.net/content/misc/2006/compare-email-regex.php
  EMAIL_VALIDATION_REGEXP   = Regexp.new('\A(?!(?:(?:\x22?\x5C[\x00-\x7E]\x22?)|(?:\x22?[^\x5C\x22]\x22?)){255,})(?!(?:(?:\x22?\x5C[\x00-\x7E]\x22?)|(?:\x22?[^\x5C\x22]\x22?)){65,}@)(?:(?:[\x21\x23-\x27\x2A\x2B\x2D\x2F-\x39\x3D\x3F\x5E-\x7E]+)|(?:\x22(?:[\x01-\x08\x0B\x0C\x0E-\x1F\x21\x23-\x5B\x5D-\x7F]|(?:\x5C[\x00-\x7F]))*\x22))(?:\.(?:(?:[\x21\x23-\x27\x2A\x2B\x2D\x2F-\x39\x3D\x3F\x5E-\x7E]+)|(?:\x22(?:[\x01-\x08\x0B\x0C\x0E-\x1F\x21\x23-\x5B\x5D-\x7F]|(?:\x5C[\x00-\x7F]))*\x22)))*@(?:(?:(?!.*[^.]{64,})(?:(?:(?:xn--)?[a-z0-9]+(?:-[a-z0-9]+)*\.){1,126}){1,}(?:(?:[a-z][a-z0-9]*)|(?:(?:xn--)[a-z0-9]+))(?:-[a-z0-9]+)*)|(?:\[(?:(?:IPv6:(?:(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){7})|(?:(?!(?:.*[a-f0-9][:\]]){7,})(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,5})?::(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,5})?)))|(?:(?:IPv6:(?:(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){5}:)|(?:(?!(?:.*[a-f0-9]:){5,})(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,3})?::(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,3}:)?)))?(?:(?:25[0-5])|(?:2[0-4][0-9])|(?:1[0-9]{2})|(?:[1-9]?[0-9]))(?:\.(?:(?:25[0-5])|(?:2[0-4][0-9])|(?:1[0-9]{2})|(?:[1-9]?[0-9]))){3}))\]))\z', true)

  def validate_each(record, attribute, value)
    begin
      invalid_emails = Mail::AddressList.new(value).addresses.map do |mail_address|
        # check if domain is present and if it passes validation through the regex
        (mail_address.domain.present? && mail_address.address =~ EMAIL_VALIDATION_REGEXP) ? nil : mail_address.address
      end

      invalid_emails.uniq!
      invalid_emails.compact!
      record.errors.add(attribute, :invalid_emails, :emails => invalid_emails.to_sentence) if invalid_emails.present?
    rescue Mail::Field::ParseError => e

      # Parse error on email field.
      # exception attributes are:
      #   e.element : Kind of element that was wrong (in case of invalid addres it is Mail::AddressListParser)
      #   e.value: mail adresses passed to parser (string)
      #   e.reason: Description of the problem. A message that is not very user friendly
      if e.reason.include?('Expected one of')
        record.errors.add(attribute, :invalid_email_list_characters)
      else
        record.errors.add(attribute, :invalid_emails_generic)
      end
    end
  end

end

และฉันใช้แบบนี้ในแบบจำลอง:

validates :emails, :presence => true, :email_list => true

มันจะตรวจสอบรายชื่ออีเมลเช่นนี้โดยมีตัวคั่นและ synthax ที่แตกต่างกัน:

mail_list = 'John Doe <john@doe.com>, chuck@schuld.dea.th; David G. <david@pink.floyd.division.bell>'

ก่อนใช้ regexp นี้ฉันเคยใช้Devise.email_regexpแต่นั่นเป็น regexp ที่เรียบง่ายมากและไม่ได้รับทุกกรณีที่ฉันต้องการ อีเมลบางฉบับกระแทก

ฉันลอง regexps อื่น ๆ จากเว็บ แต่อันนี้ได้ผลลัพธ์ที่ดีที่สุดจนถึงตอนนี้ หวังว่าจะช่วยในกรณีของคุณ