जावा रेगेक्स ईमेल

120

सबसे पहले, मुझे पता है कि ईमेल के लिए regex का उपयोग करने की अनुशंसा नहीं की गई है, लेकिन मैं इस बात का परीक्षण करूंगा।

मैं इस regex है:

\b[A-Z0-9._%-]+@[A-Z0-9.-]+\.[A-Z]{2,4}\b

जावा में, मैंने यह किया:

Pattern p = Pattern.compile("\\b[A-Z0-9._%-]+@[A-Z0-9.-]+\\.[A-Z]{2,4}\\b");
Matcher m = p.matcher("foobar@gmail.com");

if (m.find())
    System.out.println("Correct!");

हालाँकि, ईमेल का स्वागत-गठन किया गया है या नहीं, इसकी परवाह किए बिना regex विफल हो जाता है। ग्रहण के अंदर एक "ढूंढना और बदलना" उसी रेगेक्स के साथ ठीक काम करता है।

कोई उपाय?

धन्यवाद,

java  regex  email 
— तू होंग
स्रोत
3
आपके regexp के साथ एक समस्या केस-सेंसिटिविटी है। आपको अपने पैटर्न के लिए Patterm.compile ("...", Pattern.CASE_INSENSITIVE) कंस्ट्रक्टर का उपयोग करना चाहिए।
— जेसन बुबेरेल
1
जावा में ईमेल सत्यापन के लिए रीगेक्स का उपयोग करने की अनुशंसा क्यों नहीं की जाती है?
— फ़िलिपिंस मिरांडा
emailregex.com इस साइट से दिए गए rexx का उपयोग करता है। यह 99.99% सही ईमेल
— रीजेक्स

जवाबों:

246

FWIW, यहाँ जावा कोड है जिसका उपयोग हम ईमेल पतों को मान्य करने के लिए करते हैं। Regexp बहुत समान हैं:

public static final Pattern VALID_EMAIL_ADDRESS_REGEX = 
    Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

public static boolean validate(String emailStr) {
        Matcher matcher = VALID_EMAIL_ADDRESS_REGEX.matcher(emailStr);
        return matcher.find();
}

काफी मज़बूती से काम करता है।

— जेसन बुबेरेल
स्रोत
5
सिर्फ दो काउंटरटेम्पल्स: webmaster@müller.de (आपके उदाहरण से मान्य और अस्वीकृत), matteo@78.47.122.114 (मेरा ईमेल, आपके उदाहरण से मान्य और अस्वीकृत)
— Matteo
10
यह रेगेक्स अधूरा है। RFC 822 के अनुरूप सत्यापन के लिए मेरा उत्तर देखें ।
— एजबॉय
15
99.9% ईमेल पतों से मेल खाने वाले एक सरल समाधान के लिए यह एक अच्छा उपाय है।
— मैलोनी
इस regex को चेक करें यह आपके दोनों ईमेल @Matteo
— T04435
@ T04435 आप लिंक में regex डॉट से बच नहीं है। क्या रेगेक्स कार्यात्मक रूप से गलत बनाता है और इसका भी गंभीर प्रदर्शन प्रभाव पड़ता है
— टॉमवॉक
173

यहाँ RFC822 अनुरूप regex जावा के लिए अनुकूलित है:

Pattern ptr = Pattern.compile("(?:(?:\\r\\n)?[ \\t])*(?:(?:(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*|(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)*\\<(?:(?:\\r\\n)?[ \\t])*(?:@(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*(?:,@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*)*:(?:(?:\\r\\n)?[ \\t])*)?(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*\\>(?:(?:\\r\\n)?[ \\t])*)|(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)*:(?:(?:\\r\\n)?[ \\t])*(?:(?:(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*|(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)*\\<(?:(?:\\r\\n)?[ \\t])*(?:@(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*(?:,@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*)*:(?:(?:\\r\\n)?[ \\t])*)?(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*\\>(?:(?:\\r\\n)?[ \\t])*)(?:,\\s*(?:(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*|(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)*\\<(?:(?:\\r\\n)?[ \\t])*(?:@(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*(?:,@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*)*:(?:(?:\\r\\n)?[ \\t])*)?(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\"(?:[^\\\"\\r\\\\]|\\\\.|(?:(?:\\r\\n)?[ \\t]))*\"(?:(?:\\r\\n)?[ \\t])*))*@(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*)(?:\\.(?:(?:\\r\\n)?[ \\t])*(?:[^()<>@,;:\\\\\".\\[\\] \\000-\\031]+(?:(?:(?:\\r\\n)?[ \\t])+|\\Z|(?=[\\[\"()<>@,;:\\\\\".\\[\\]]))|\\[([^\\[\\]\\r\\\\]|\\\\.)*\\](?:(?:\\r\\n)?[ \\t])*))*\\>(?:(?:\\r\\n)?[ \\t])*))*)?;\\s*)");
String[] emails = { "\"Fred Bloggs\"@example.com", "user@.invalid.com", "Chuck Norris <gmail@chucknorris.com>", "webmaster@müller.de", "matteo@78.47.122.114" };
for (String email : emails) {
    System.out.println(email + " is " + (ptr.matcher(email).matches() ? "valid" : "invalid"));
}

आउटपुट:

"Fred Bloggs"@example.com is valid
user@.invalid.com is invalid
Chuck Norris <gmail@chucknorris.com> is valid
webmaster@müller.de is valid
matteo@78.47.122.114 is valid

इस पोस्ट से regex लिया गया है: मेल :: RFC822 :: पता: regexp- आधारित पता सत्यापन । परिणाम ऑनलाइन संस्करण के साथ मेल खाना चाहिए ।

— ejboy
स्रोत
2
मुझे लगता है कि उसने इसे डाउनग्रेड किया क्योंकि किसी को विशेष पात्रों को "संकलन से पहले" से बचना पड़ता है। जब तक कि वाक्यविन्यास में कोई त्रुटि नहीं होगी।
— इसुरु मदुसंका
1
धन्यवाद इसुरु! मुझे याद है कि मैं कुछ साल पहले अपनी एक परियोजना पर इस रेगेक्स का उपयोग कर रहा था, लेकिन मैं यह भूल गया कि इसे समतल करने और इसे ठीक से चमकाने के लिए थोड़ा सा चमकाने की जरूरत है। वास्तव में IntelliJ एक अच्छा काम करता है स्वचालित रूप से डबल कोट्स के अंदर पेस्ट की गई अभिव्यक्ति से बचकर।
— एजबॉय
5
यह पैटर्न RFC822 कल्पना के खिलाफ मान्य है, लेकिन यह जवाब नहीं देता कि ईमेल पता किसी मौजूदा मेल सर्वर की ओर इशारा करता है या नहीं। इसके अतिरिक्त, शीर्ष स्तर डोमेन केवल 3 वर्णों तक सीमित नहीं हैं। अब TLD हैं और सूची बढ़ रही है। IMO मामलों की वैधता की जांच करने का एकमात्र तरीका है जब कोई मेल सर्वर के अस्तित्व की जांच करना चाहता है, तो DNS के माध्यम से होस्ट नाम को हल करना है, और / या mx रिकॉर्ड देखने की कोशिश करें।
— ejboy 15
5
यह email@emailएक वैध ईमेल के रूप में मान्य है
— lxknvlk
2
मार्क्स "मैट रोडर" @ gmail.com वैध के रूप में, जो कि RFC822-अनुरूप नहीं है अगर मैं सही हूं
— आस्कर कल्यकोव
15

मत करो।आप एक मान्य अभिव्यक्ति के साथ कभी समाप्त नहीं होंगे।

उदाहरण के लिए ये सभी मान्य ईमेल पते हैं: 

"Abc\@def"@example.com
"Fred Bloggs"@example.com
"Joe\\Blow"@example.com
"Abc@def"@example.com
customer/department=shipping@examp­ le.com
$A12345@example.com
!def!xyz%abc@example.com
_somename@example.com
matteo(this is a comment).corti@example.com
root@[127.0.0.1]

बस कुछ समस्याओं का उल्लेख करने के लिए:

  • आप एक होस्ट को निर्दिष्ट करने के कई रूपों पर विचार नहीं करते हैं (उदाहरण के लिए, आईपी पते द्वारा)
  • आपको मान्य वर्ण याद आते हैं
  • आप गैर ASCII डोमेन नाम याद करते हैं

शुरुआत से पहले भी इसी RFC की जाँच करें

— Matteo
स्रोत
2
रिक्त स्थान के साथ ई-मेल? यह बहुत अमान्य लगता है, भले ही कहीं यह निर्णय लिया गया था कि ई-मेल में रिक्त स्थान हो सकते हैं।
— बर्गा
emailregex.com इस साइट पर ईमेल के लिए 99% प्रतिशत सही रीगेक्स का दावा है
— मेनुका इशान
1
@MenukaIshan जैसा कि वे खुद का दावा करते हैं regex कभी भी पूरी तरह से ठीक नहीं होगा। आप ऊपर दिए गए कई उदाहरणों का परीक्षण कर सकते हैं। अब सवाल यह है कि जहां कार्य लागू होते हैं वहां रजिस्ट्रियां क्यों होती हैं?
— मट्टियो
1
@ माटेयो क्या आप मुझे ऐसा उदाहरण दे सकते हैं जिसमें रेगेक्स की आवश्यकता न हो? मुझे हाइबरनेट वैलिडेटर @ ईमेल एनोटेशन के बारे में पता है। क्या आप इस प्रकार की बातें कर रहे हैं? वैसे भी मैं आपके उदाहरणों को जानना पसंद करूंगा ताकि मैं उन्हें अपने भविष्य के विकास में उपयोग कर सकूं। धन्यवाद।
— मेनुका ईशान
कौन सी भाषा का उपयोग कर रहे हैं?
— मट्टियो
7

ऐसा इसलिए है क्योंकि आप मामला असंवेदनशीलता भूल रहे हैं: 

Pattern regex = Pattern.compile("\\b[\\w.%-]+@[-.\\w]+\\.[A-Za-z]{2,4}\\b");

यह आपके उदाहरण से मेल खाता है, हालांकि यह कई वैध ई-मेलों को नजरअंदाज करता है।

— FailedDev
स्रोत
5

99% ईमेल को मान्य करने के लिए एक और सरल विकल्प

public static final String EMAIL_VERIFICATION = "^([\\w-\\.]+){1,64}@([\\w&&[^_]]+){2,255}.[a-z]{2,}$";
— अरमर बी।
स्रोत
1
मुझे यह पसंद है क्योंकि यह सरल और समझ में आता है, एक चीज जो याद आ रही है वह अंतरराष्ट्रीय भाषा समर्थन है (föö@bar.com आजकल मान्य है) बस \ w के लिए \ w को स्विच करना {L} किसी भी भाषा के अक्षरों को अनुमति देता है। मैं समाप्त हो गया: "^ ([\ p {L} -_ \]।] +) {1,64} @ ([\ p {L} -_ \]।] +) {2,255}। [Az] {2 ,} $ "
— टोबी नॉनसम
3

यह ई-मेल को मान्य करने के लिए एक वैध रेगेक्स है। यह पूरी तरह से RFC822 के अनुरूप है और IP पते और सर्वर नामों (इंट्रानेट उद्देश्यों के लिए) को स्वीकार करता है।

public static boolean isEmailValid(String email) {
    final Pattern EMAIL_REGEX = Pattern.compile("[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?", Pattern.CASE_INSENSITIVE);
    return EMAIL_REGEX.matcher(email).matches();
}

जब आप कॉल करते हैं तो यहां कुछ आउटपुट उदाहरण दिए गए हैं isEmailValid(emailVariable):

john@somewhere.com // valid
john.foo@somewhere.com // valid
john.foo+label@somewhere.com // valid (with +label - Gmail accepts it!)
john@192.168.1.10 // valid (with IP addresses)
john+label@192.168.1.10 // valid (with +label and IP address)
john.foo@someserver // valid (with no first domain level)
JOHN.FOO@somewhere.com // valid (case insensitive)
@someserver // invalid
@someserver.com // invalid
john@. // invalid
.@somewhere.com // invalid
— shimatai
स्रोत
1

आप जावा में ईमेल पते को मान्य करने के लिए इस विधि का उपयोग कर सकते हैं।

public class EmailValidator {
    private Pattern pattern;
    private Matcher matcher;

    private static final String EMAIL_PATTERN = 
        "^[_A-Za-z0-9-\\+]+(\\.[_A-Za-z0-9-]+)*@"
        + "[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$";

    public EmailValidator() {
        pattern = Pattern.compile(EMAIL_PATTERN);
    }

    /**
    * Validate hex with regular expression
    * 
    * @param hex
    *            hex for validation
    * @return true valid hex, false invalid hex
    */
    public boolean validate(final String hex) {

    matcher = pattern.matcher(hex);
    return matcher.matches();

    }
}
— चनाका उडाया
स्रोत
1

सामान्य ईमेल प्रारूप (आरई) जिसमें डोमेन जैसे co.in, co.uk, com, outlook.com आदि शामिल हैं।

और नियम कहता है कि:

  • अपरकेस और अंग्रेजी अक्षरों को कम करना (az, AZ)
  • अंक 0 से 9
  • पात्र ! # $% & '* + - / =? ^ _ `{| } ~ चरित्र।

  • (डॉट, पीरियड, फुल स्टॉप) बशर्ते कि यह पहला या आखिरी चरित्र न हो, और यह भी प्रदान किया जाए कि यह लगातार दो या दो से अधिक दिखाई न दे।

    [a-zA-Z0-9]+[._a-zA-Z0-9!#$%&'*+-/=?^_`{|}~]*[a-zA-Z]*@[a-zA-Z0-9]{2,8}.[a-zA-Z.]{2,6}
— हितेश कलवानी
स्रोत
1

Armer B. उत्तर का संशोधन जो '.co.uk' के साथ समाप्त होने वाले ईमेल को मान्य नहीं करता था

public static boolean emailValidate(String email) {
    Matcher matcher = Pattern.compile("^([\\w-\\.]+){1,64}@([\\w&&[^_]]+){2,255}(.[a-z]{2,3})+$|^$", Pattern.CASE_INSENSITIVE).matcher(email);

    return matcher.find();
}
— एलेक्स हॉडसन
स्रोत
0

Regex: ^[\\w!#$%&’*+/=?{|} ~ ^ -] + (?: \? [\ W! # $% & '* + / =?{|}~^-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,6}$

public static boolean isValidEmailId(String email) {
        String emailPattern = "^[\\w!#$%&’*+/=?`{|}~^-]+(?:\\.[\\w!#$%&’*+/=?`{|}~^-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,6}$";
        Pattern p = Pattern.compile(emailPattern);
        Matcher m = p.matcher(email);
        return m.matches();
    }
— नव
स्रोत
0

यदि आप गैर-अक्षांश पात्रों की अनुमति देना चाहते हैं, तो यह मेरे लिए बहुत अच्छा काम करता है।

"^[\\p{L}\\p{N}\\._%+-]+@[\\p{L}\\p{N}\\.\\-]+\\.[\\p{L}]{2,}$"

यह आईपी के @ के बाद की अनुमति नहीं देता है लेकिन इसमें से सबसे वैध ईमेल xxx@xxx.TDLको इसके साथ मान्य किया जा सकता है। \p{L}UTF- पत्र को \p{N}मान्य करता है और UTF- संख्या को मान्य करता है। अधिक जानकारी के लिए आप इस दस्तावेज़ को देख सकते हैं।

— नबील ए।
स्रोत
0

ईमेल के लिए नीचे दिए गए कोड का प्रयास करें का प्रारूप है 

jsmith@example.com

पहला भाग -jsmith २ भाग-@example.com

1. In the 1 part it will allow 0-9,A-Z,dot sign(.),underscore sign(_)
 2. In the 2 part it will allow A-Z, must be @ and .

^[a-zA-Z0-9_.]+@[a-zA-Z.]+?\.[a-zA-Z]{2,3}$
— चरण
स्रोत
0

मैंने नीचे दिए गए regular expressionएकल और कई लगातार डॉट्स के लिए इसका परीक्षण किया है domain-

([A-Za-z0-9-_.]+@[A-Za-z0-9-_]+(?:\.[A-Za-z0-9]+)+)

और यहाँ ऐसे उदाहरण हैं जो ऊपर से पूरी तरह से पूरे हो चुके थे regex।

End_user@live.com
End.u@exm-tech.net
enduser9876@gmail.in
end_user@mywebsite.ac.in.gui
Another984.User2@mail.edu.sg
Another987_User5@mail.show.au
Slow_User@example_domain.au.in
iamthemostsimpleremailhere@example.com

मैंने यह सचित्र और अभी तक काम कर रहे ऊपर द्वारा आमतौर पर उपयोग email id's validation किए जाने वाले अधिकतम को कवर करने की कोशिश की है regex...

यदि आप अभी भी जानते हैं कि कुछ परिणामी उपयोग email id'sयहाँ छोड़ दिए गए हैं, तो कृपया मुझे टिप्पणी अनुभाग में बताएं!

— ArifMustafa
स्रोत
0 
String emailRegex = "[a-zA-Z0-9_.]+@[a-zA-Z0-9]+.[a-zA-Z]{2,3}[.] {0,1}[a-zA-Z]+";
Pattern.matches(emailRegex,"You_Input_Mail_Id");

यह मान्य ईमेल पते से मिलान करने के लिए regex है।

— prakhar9293
स्रोत
भविष्य के पाठकों को इसके अर्थ को बेहतर ढंग से समझने में मदद करने के लिए अपने कोड में कुछ प्रारूपण और संदर्भ जोड़ने का प्रयास करें।
— ग्रांट मिलर
0

आप ईमेल आईडी को मान्य करने के लिए एक सरल नियमित अभिव्यक्ति का उपयोग कर सकते हैं, 

public boolean validateEmail(String email){
  return Pattern.matches("[_a-zA-Z1-9]+(\\.[A-Za-z0-9]*)*@[A-Za-z0-9]+\\.[A-Za-z0-9]+(\\.[A-Za-z0-9]*)*", email)
}

विवरण :

  1. [_a-zA-Z1-9] + - यह सभी AZ, az, 0-9 और _ को स्वीकार करेगा (+ इसका मतलब यह होना चाहिए)
  2. (+! [A-Za-z0-9] ) - यह वैकल्पिक है जो स्वीकार करेगा। और AZ, az, 0-9 (* इसका अर्थ वैकल्पिक)
  3. @ [A-Za-z0-9] + - यह wil स्वीकार @ और AZ, az, 0-9
  4. \। [A-Za-z0-9] + - इसके लिए। और एज़, एज़, 0-9
  5. (\ "[ए-ज़-ज़0-9] ) - यह होता है,। लेकिन इसके वैकल्पिक
— विवेक हांडे
स्रोत
0

आप यह जाँच कर सकते हैं कि इस लाइब्रेरियों का उपयोग करके ईमेल वैध है या नहीं, और निश्चित रूप से आप इस फ़ॉउलिंग प्रोजेक्ट के लिए सरणी जोड़ सकते हैं।

import org.apache.commons.validator.routines.EmailValidator;

public class Email{
    public static void main(String[] args){
        EmailValidator email = EmailVlidator.getInstance();
        boolean val = email.isValid("george.parcks@gmail.com");
        System.out.println("Mail is: "+val);
        val = email.isValid("hans.riguer.hotmsil.com");
        System.out.print("Mail is: "+val");
    }
}

आउटपुट:

मेल है: सच

मेल है: असत्य

— फ्रिडजैटो पार्ट फ्रिडजैट
स्रोत
यह अच्छा है कि यह एक पुस्तकालय है, लेकिन इस्तेमाल किया गया रेक्सक्स वास्तव में सरल है ... EMAIL_REGEX = "^ \\ \ * *? ((+ +) @ (?)? \\ s * $"।
— मिलो वैन डेर ज़ी
0 
import java.util.Scanner;

public class CheckingTheEmailPassword {

    public static void main(String[] args) {
        String email = null;
        String password = null;
        Boolean password_valid = false;
        Boolean email_valid = false;

        Scanner input = new Scanner(System.in);
        do {
            System.out.println("Enter your email: ");
            email = input.nextLine();

            System.out.println("Enter your passsword: ");
            password = input.nextLine();

            // checks for words,numbers before @symbol and between "@" and ".".
            // Checks only 2 or 3 alphabets after "."
            if (email.matches("[\\w]+@[\\w]+\\.[a-zA-Z]{2,3}"))
                email_valid = true;
            else
                email_valid = false;

            // checks for NOT words,numbers,underscore and whitespace.
            // checks if special characters present
            if ((password.matches(".*[^\\w\\s].*")) &&
            // checks alphabets present
                    (password.matches(".*[a-zA-Z].*")) &&
                    // checks numbers present
                    (password.matches(".*[0-9].*")) &&
                    // checks length
                    (password.length() >= 8))
                password_valid = true;
            else
                password_valid = false;

            if (password_valid && email_valid)
                System.out.println(" Welcome User!!");
            else {
                if (!email_valid)
                    System.out.println(" Re-enter your email: ");
                if (!password_valid)
                    System.out.println(" Re-enter your password: ");
            }

        } while (!email_valid || !password_valid);

        input.close();

    }

}
— अनु सठिया
स्रोत
0

@ जैसन बुबेरेल के जवाब के लिए, मुझे लगता है कि लोअरकेस अक्षरों को RegEX द्वारा मान्य किया जाना चाहिए। तो निम्नलिखित सही है:

[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}

अब, developer961@mail.com और DEV961@yahoo.COM दोनों वैध हैं!
ध्यान दें कि \। \\ होना चाहिए । पलायन करना । और है । अपने आप। के बाद से, । जावा में एक सार्थक चरित्र है RegEX का अर्थ है सभी वर्ण।

— मोहसिन अबसी
स्रोत
जेसन के जवाब का उपयोग करता है Pattern.CASE_INSENSITIVE, इसलिए कोई के लिए की जरूरत हैa-z
— टोटो
-1

Facebook जैसी मान्यता के लिए Regex:

public static final String REGEX_EMAIL_VALIDATION = "^[\\w-\\+]+(\\.[\\w]+)*@[\\w-]+(\\.[\\w]+)*(\\.[a-zA-Z]{2,})$";

यूनिट टेस्ट के लिए Dto (लोम्बोक के साथ):

@Data
@Accessors(chain = true)
@FieldDefaults(level = AccessLevel.PRIVATE)
public class UserCreateDto {

    @NotNull
    @Pattern(regexp = REGEX_EMAIL_VALIDATION)
    @Size(min = 1, max = 254)
    String email;
}

यूनिट परीक्षणों के साथ मान्य / अमान्य ईमेल:

public class UserCreateValidationDtoTest {

private static final String[] VALID_EMAILS = new String[]{"email@yahoo.com", "email-100@yahoo.com",
        "Email.100@yahoo.com", "email111@email.com", "email-100@email.net",
        "email.100@email.com.au", "emAil@1.com", "email@gmail.com.com",
        "email+100@gmail.com", "emAil-100@yahoo-test.com", "email_100@yahoo-test.ABC.CoM"};
private static final String[] INVALID_EMAILS = new String[]{"あいうえお@example.com", "email@111",
        "email", "email@.com.my", "email123@gmail.", "email123@.com", "email123@.com.com",
        ".email@email.com", "email()*@gmAil.com", "eEmail()*@gmail.com", "email@%*.com", "email..2002@gmail.com",
        "email.@gmail.com", "email@email@gmail.com", "email@gmail.com."};
private Validator validator;

@Before
public void setUp() throws Exception {
    ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
    validator = factory.getValidator();
}

@Test
public void emailValidationShouldBeValid() throws Exception {
    Arrays.stream(VALID_EMAILS)
            .forEach(email -> {
                        Set<ConstraintViolation<UserCreateDto>> violations = validateEmail(
                                new UserCreateDto().setEmail(email));
                        System.out.println("Email: " + email + ", violations: " + violations);
                        Assert.assertTrue(violations.isEmpty());
                    }
            );
}

@Test
public void emailValidationShouldBeNotValid() throws Exception {
    Arrays.stream(INVALID_EMAILS)
            .forEach(email -> {
                        Set<ConstraintViolation<UserCreateDto>> violations = validateEmail(
                                new UserCreateDto().setEmail(email));
                        System.out.println("Email: " + email + ", violations: " + violations);
                        Assert.assertTrue(!violations.isEmpty());
                    }
            );
}


private Set<ConstraintViolation<UserCreateDto>> validateEmail(UserCreateDto user) {
    String emailFieldName = "email";
    return validator.validateProperty(user, emailFieldName);
}

}

— एलेक्स एफिमोव
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.