रेगुलर एक्सप्रेशन का उपयोग करके उपयोगकर्ता खाता विवरण को कैसे सत्यापित करें

रेगुलर एक्सप्रेशंस एक अभिन्न प्रोग्रामिंग टूल है जिसका उपयोग आप कई व्यावहारिक दैनिक कार्यों के लिए कर सकते हैं। टेक्स्ट को खोजने, मिलान करने या पार्स करने के लिए आप रेगुलर एक्सप्रेशन का उपयोग कर सकते हैं। सही पैटर्न के साथ, आप कुछ सबसे सामान्य उपयोगकर्ता खाता विवरणों को मान्य कर सकते हैं।

आप पायथन और जावास्क्रिप्ट सहित कई भाषाओं या टूल के साथ रेगुलर एक्सप्रेशन का उपयोग कर सकते हैं।

एक उपयोगकर्ता नाम मान्य करने के लिए Regex

एक उपयोगकर्ता नाम पर विचार करें जो केवल तभी मान्य होता है जब वह निम्नलिखित शर्तों को पूरा करता हो:

1. वर्णों की संख्या 5 और 15 के बीच होनी चाहिए. (आप अपनी आवश्यकताओं के अनुसार एक अलग श्रेणी निर्दिष्ट कर सकते हैं, लेकिन रेगेक्स में तदनुसार परिवर्तन करें।)
instagram viewer
2. स्ट्रिंग में केवल अल्फ़ान्यूमेरिक वर्ण और/या अंडरस्कोर (_) होने चाहिए।
3. स्ट्रिंग का पहला अक्षर अल्फ़ाबेटिक होना चाहिए।

निम्नलिखित रेगेक्स उपरोक्त शर्तों को पूरा करता है और एक उपयोगकर्ता नाम को मान्य कर सकता है:

^[ए-ज़ा-जेड]\\w{4,14}$

यदि आप उपरोक्त अभिव्यक्ति से सहज नहीं हैं, तो देखें रेगुलर एक्सप्रेशंस के लिए शुरुआती गाइड पहला। उपयोगकर्ता नाम को प्रमाणित करने के लिए यह एक पायथन दृष्टिकोण है:

आयात दोबारा
डीईएफ़checkUsername(उपयोगकर्ता नाम):
 रेगेक्स = "^[ए-ज़ा-जेड]\\w{4,14}$"
 r = re.compile (रेगेक्स)
अगर (दोबारा।खोज(आर, उपयोगकर्ता नाम)):
 प्रिंट ("वैध")
अन्य:
 प्रिंट ("मान्य नहीं है")
उपयोगकर्ता नाम 1 = "युवराज_चंद्र"
चेक उपयोगकर्ता नाम (उपयोगकर्ता नाम 1)
उपयोगकर्ता नाम2 = "ja7&^%87"
चेक उपयोगकर्ता नाम (उपयोगकर्ता नाम 2)

इस कोड को चलाने से पुष्टि होगी कि पहला उपयोगकर्ता नाम मान्य है लेकिन दूसरा नहीं है:

इसी तरह, आप निम्नलिखित कोड का उपयोग करके जावास्क्रिप्ट में उपयोगकर्ता नाम को मान्य कर सकते हैं:

समारोहcheckUsername(उपयोगकर्ता) {
अगर(/^[A-Za-z][A-Za-z0-9_]{4,14}$/परीक्षण (उपयोगकर्ता)) {
 कंसोल लॉग ('वैध');
 } अन्य {
 कंसोल लॉग ('मान्य नहीं है');
 }
}
चेकयूजरनेम('युवराज_चंद्र');
चेकयूजरनेम('ja7&^%87'); 

आप इस कोड का उपयोग कर सकते हैं रेगुलर एक्सप्रेशन का उपयोग करके HTML फॉर्म को मान्य करें.

एक ईमेल पता मान्य करने के लिए Regex

ईमेल पते को प्रमाणित करने के लिए रेगेक्स सही नहीं है। ईमेल पते को मान्य करने के लिए कोई सार्वभौमिक रूप से स्वीकृत रेगेक्स नहीं है। यह वैध की आपकी परिभाषा के लिए पूरी तरह से उबलता है।

नीचे उन शर्तों की सूची दी गई है जो अधिकांश ईमेल पतों को मान्य कर सकती हैं:

1. उपयोगकर्ता नाम में केवल अल्फ़ान्यूमेरिक, अंडरस्कोर, डैश और/या डॉट वर्ण होने चाहिए।
2. ईमेल आईडी स्ट्रिंग में एक @ वर्ण होना चाहिए।
3. डोमेन नाम में केवल अल्फ़ान्यूमेरिक, अंडरस्कोर या डैश वर्ण होने चाहिए।
4. डोमेन नाम के बाद एक डॉट होना चाहिए।
5. डोमेन एक्सटेंशन में केवल अल्फ़ान्यूमेरिक, अंडरस्कोर या डैश वर्ण होने चाहिए।
6. डोमेन एक्सटेंशन की लंबाई 2 और 4 के बीच होनी चाहिए।

निम्नलिखित रेगेक्स उपरोक्त शर्तों को पूरा करता है और एक ईमेल पते को मान्य कर सकता है:

^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$

ईमेल पते को मान्य करने के लिए यह एक पायथन दृष्टिकोण है:

आयात दोबारा
डीईएफ़ईमेल आईडी चेक करें(ईमेल):
 रेगेक्स = "^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$"
 r = re.compile (रेगेक्स)
अगर (दोबारा।खोज(आर, ईमेल)):
 प्रिंट ("वैध")
अन्य:
 प्रिंट ("मान्य नहीं है")
ईमेल1 = "[email protected]"
ईमेल आईडी चेक करें (ईमेल1)
ईमेल2 = "एबीसी@def@जीमेल लगीं.काहस्ग"
ईमेल आईडी चेक करें (ईमेल2)

दोबारा, आउटपुट पुष्टि करता है कि पहला ईमेल पता मान्य है जबकि दूसरा अमान्य है:

आप निम्नलिखित कोड का उपयोग करके जावास्क्रिप्ट में एक ईमेल को मान्य कर सकते हैं:

समारोहईमेल आईडी चेक करें(ईमेल) {
अगर (/^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$/.परीक्षण (ईमेल)) {
सांत्वना देनालॉग ('मान्य');
 } अन्य {
सांत्वना देनालॉग ('मान्य नहीं');
 }
}
checkEmailId ("[email protected]");
checkEmailId ("abc@[email protected]");

रेगुलर एक्सप्रेशंस का उपयोग करके पासवर्ड की शक्ति की जाँच करें

सुरक्षा के नजरिए से स्ट्रांग पासवर्ड जरूरी है। आपको यह सुनिश्चित करने की आवश्यकता है कि अंतिम उपयोगकर्ताओं के पास पर्याप्त मजबूत पासवर्ड हों ताकि अन्य लोग उनके खातों तक न पहुंच सकें।

निम्नलिखित नियम सुनिश्चित करते हैं कि आपके एप्लिकेशन की पासवर्ड शक्ति मजबूत है:

1. वर्णों की न्यूनतम संख्या 8 होनी चाहिए।
2. स्ट्रिंग में कम से कम एक अंक होना चाहिए।
3. स्ट्रिंग में कम से कम एक अपरकेस वर्ण होना चाहिए।
4. स्ट्रिंग में कम से कम एक लोअरकेस वर्ण होना चाहिए।
5. स्ट्रिंग में कम से कम एक विशेष वर्ण होना चाहिए।

निम्नलिखित रेगेक्स उपरोक्त शर्तों को पूरा करता है और एक मजबूत पासवर्ड सुनिश्चित करने में मदद कर सकता है:

(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{ 8,})

आप निम्न कोड का उपयोग करके पायथन में पासवर्ड की ताकत की जांच कर सकते हैं:

आयात दोबारा
डीईएफ़checkPasswordStrength(पासवर्ड):
 रेगेक्स = "(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{ 8,})"
 r = re.compile (रेगेक्स)
अगर (दोबारा।खोज(आर, पासवर्ड)):
 प्रिंट ("मज़बूत पारण शब्द")
अन्य:
 प्रिंट ("कमजोर पासवर्ड")
पासवर्ड1 = "$5jawd"
चेकपासवर्डस्ट्रेंथ (पासवर्ड1)
पासवर्ड2 = "मेरा पासवर्ड"
चेकपासवर्डस्ट्रेंथ (पासवर्ड2)

इस कोड को चलाने से पुष्टि होगी कि पहला पासवर्ड मजबूत है जबकि दूसरा कमजोर है:

आप निम्नलिखित कोड का उपयोग करके जावास्क्रिप्ट में पासवर्ड की ताकत की जांच कर सकते हैं:

समारोहcheckPasswordStrength(पासवर्ड) {
अगर (/(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{8,})/परीक्षण (पासवर्ड)) {
 कंसोल लॉग ('मज़बूत पारण शब्द');
 } अन्य {
 कंसोल लॉग ('कमजोर पासवर्ड');
 }
}
चेकपासवर्डस्ट्रेंथ('$5jawd');
चेकपासवर्डस्ट्रेंथ('मेरा पासवर्ड');

वैध तिथि से मिलान करने के लिए नियमित अभिव्यक्ति

यदि आप जल्दी से जांचना चाहते हैं कि दी गई तिथियां पारंपरिक तिथि प्रारूप में हैं या नहीं, तो आप रेगेक्स का उपयोग करके ऐसा कर सकते हैं।

निम्न रेगुलर एक्सप्रेशन में दिनांक से मेल खाता है मिमी/दिन/वर्ष प्रारूप:

^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20 )\d\d$

निम्नलिखित पायथन कोड मान्य करता है कि दिनांक अंदर है मिमी/दिन/वर्ष प्रारूप:

आयात दोबारा
डीईएफ़checkDateFormat(तारीख):
 रेगेक्स = "^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20 )\d\d$"
 r = re.compile (रेगेक्स)
अगर(दोबारा।खोज(आर, तारीख)):
 प्रिंट ("वैध")
अन्य:
 प्रिंट ("मान्य नहीं है")
दिनांक 1 = "03/21/2002"
checkDateFormat (तारीख1)
दिनांक 2 = "15/21/2002"
checkDateFormat (तारीख 2)

एक बार फिर, आउटपुट पुष्टि करता है कि पहली तारीख का प्रारूप मान्य है, लेकिन दूसरा अमान्य है:

आप दिनांक को मान्य कर सकते हैं मिमी/दिन/वर्ष निम्नलिखित कोड का उपयोग करके जावास्क्रिप्ट में प्रारूप:

समारोहcheckDateFormat(तारीख) {
अगर(/^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19| 20)\d\d$/।परीक्षा की तारीख)) {
 कंसोल लॉग ('वैध');
 } अन्य {
 कंसोल लॉग ('मान्य नहीं है');
 }
}
चेकडेटफॉर्मेट('03/21/2002');
चेकडेटफॉर्मेट('15/21/2002');

रेगुलर एक्सप्रेशंस का उपयोग करते हुए खाली स्ट्रिंग सत्यापन

आप निम्न रेगुलर एक्सप्रेशन का उपयोग करके जाँच सकते हैं कि कोई स्ट्रिंग खाली है या नहीं:

^$

नीचे खाली स्ट्रिंग सत्यापन के लिए पायथन दृष्टिकोण है:

आयात दोबारा
डीईएफ़checkEmptyString(एसटीआर):
 रेगेक्स = "^$"
 r = re.compile (रेगेक्स)
अगर (दोबारा।खोज(आर, एसटीआर)):
छपाई("दी गई स्ट्रिंग है खाली")
अन्य:
छपाई("दी गई स्ट्रिंग नहीं है खाली")
str1 = ""
checkEmptyString (str1)
str2 = "यह कोई खाली स्ट्रिंग नहीं है"
checkEmptyString (str2)

निम्न आउटपुट दर्शाता है कि पहला दिया गया स्ट्रिंग खाली है जबकि दूसरा नहीं है:

स्ट्रिंग खाली है या नहीं, यह जांचने के लिए निम्न जावास्क्रिप्ट कोड का उपयोग करें:

समारोहcheckEmptyString(एसटीआर) {
अगर (/^$/टेस्ट (एसटीआर)) {
 कंसोल लॉग ('दी गई स्ट्रिंग खाली है');
 } अन्य {
 कंसोल लॉग ('दी गई स्ट्रिंग खाली नहीं है');
 }
}
चेकEmptyString('');
चेकEmptyString('यह कोई खाली स्ट्रिंग नहीं है'); 

ज़िप कोड (यूएस पोस्टल कोड) को मान्य करने के लिए RegEx

आप निम्नलिखित रेगुलर एक्सप्रेशन का उपयोग करके एक ज़िप कोड (यू.एस. पोस्टल कोड) को पांच अंकों और नौ अंकों (जिन्हें ज़िप+4 कहा जाता है) दोनों स्वरूपों में मान्य कर सकते हैं:

^[0-9]{5}(?:-[0-9]{4})?$

नीचे ज़िप कोड मान्य करने के लिए पायथन कोड है:

आयात दोबारा
डीईएफ़सत्यापित करेंZIPCode(कोड):
 रेगेक्स = "^[0-9]{5}(?:-[0-9]{4})?$"
 r = re.compile (रेगेक्स)
अगर (दोबारा।खोज(आर, कोड)):
 प्रिंट ("वैध")
अन्य:
 प्रिंट ("मान्य नहीं है")
कोड1 = "76309"
सत्यापित करेंZIPCode (कोड 1)
कोड2 = "83468-2348"
सत्यापित करेंZIPCode (कोड2)
कोड3 = "234445"
सत्यापित करेंZIPCode (कोड3)

इस कोड को चलाने से पुष्टि होगी कि पहला और दूसरा ज़िप कोड मान्य हैं लेकिन तीसरा नहीं है:

रेगेक्स का उपयोग करके ज़िप कोड को मान्य करने के लिए निम्नलिखित जावास्क्रिप्ट कोड का उपयोग करें:

समारोहसत्यापित करेंZIPCode(कोड) {
अगर (/^[0-9]{5}(?:-[0-9]{4})?$/परीक्षण (कोड)) {
 कंसोल लॉग ('वैध');
 } अन्य {
 कंसोल लॉग ('मान्य नहीं है');
 }
}
मान्यज़िपकोड('76309');
मान्यज़िपकोड('83468-2348');
मान्यज़िपकोड('234445');

मजबूत कोड के साथ उपयोगकर्ता इनपुट सत्यापित करें

आपने सीखा कि रेगुलर एक्सप्रेशन का उपयोग करके उपयोगकर्ता खाता विवरण को कैसे सत्यापित किया जाता है। इन विवरणों को मान्य करने से कोड मजबूत होता है और सुरक्षा मुद्दों और अवांछित बगों से निपटने में मदद मिलती है। मजबूत कोड आपके उपयोगकर्ताओं के लिए एक सुरक्षित और सुरक्षित अनुभव प्रदान करता है।

आपको यह सुनिश्चित करना चाहिए कि आप हैकर्स से हमेशा सुरक्षित पक्ष में रहने के लिए इनपुट डेटा को ग्राहक पक्ष या सर्वर पक्ष पर मान्य कर रहे हैं।