पासवर्ड के लिए रेगेक्स में कम से कम आठ अक्षर, कम से कम एक संख्या और निचले और बड़े अक्षर और विशेष अक्षर दोनों होने चाहिए

Question

मैं चाहता हूँ कि एक नियमित अभिव्यक्ति की जाँच करें:

एक पासवर्ड कम से कम एक नंबर सहित कम से कम आठ वर्ण हैं, और कम और बड़े अक्षरों और विशेष वर्ण दोनों शामिल हैं, उदाहरण के लिए #, ?, !।

यह आपका पुराना पासवर्ड नहीं हो सकता है या आपके उपयोगकर्ता नाम "password", या हो सकता है"websitename"

और यहाँ मेरी मान्यता अभिव्यक्ति है जो एक अपरकेस अक्षर, एक लोअरकेस अक्षर, और एक नंबर या विशेष चरित्र सहित आठ वर्णों के लिए है।

(?=^.{8,}$)((?=.*\d)|(?=.*\W+))(?![.\n])(?=.*[A-Z])(?=.*[a-z]).*$"

मैं एक पासवर्ड के लिए इसे कैसे लिख सकता हूं एक अपरकेस अक्षर, एक विशेष चरित्र और अल्फ़ान्यूमेरिक वर्ण सहित आठ वर्ण होने चाहिए ?

Answer 1

न्यूनतम आठ अक्षर, कम से कम एक अक्षर और एक संख्या:

"^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$"

न्यूनतम आठ वर्ण, कम से कम एक अक्षर, एक संख्या और एक विशेष वर्ण:

"^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\d@$!%*#?&]{8,}$"

न्यूनतम आठ वर्ण, कम से कम एक अपरकेस अक्षर, एक निचला अक्षर और एक संख्या:

"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$"

न्यूनतम आठ वर्ण, कम से कम एक अपरकेस अक्षर, एक निचला अक्षर, एक संख्या और एक विशेष वर्ण:

"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$"

न्यूनतम आठ और अधिकतम 10 वर्ण, कम से कम एक अपरकेस अक्षर, एक निचला अक्षर, एक संख्या और एक विशेष वर्ण:

"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,10}$"

Comments

"^ ^! =। * [A-Za-z]) (? =। * \ D) [A-Za-z \ d] {8,} $" 8 अक्षरों में से एक के रूप में प्रतीकों की अनुमति नहीं देता है

— Wee

मैंने पाया कि सभी पात्रों (विशेष और विराम चिह्न) के लिए अनुमति दी गई थी, उन्हें अनिवार्य किए बिना: "^ (? =। * [Az]) ((=। *। [AZ]) ((? =। * * D) [a- zA-Z \ d \ w \ W] {8,} $ "

— गेविन

Answer 2

आप इस regex का उपयोग कई लुकहेड अभिकथनों (स्थितियों) के साथ कर सकते हैं :

^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9])(?=.*?[#?!@$%^&*-]).{8,}$

यह रेगेक्स इन नियमों को लागू करेगा:

• कम से कम एक ऊपरी मामला अंग्रेजी पत्र ,(?=.*?[A-Z])
• कम से कम एक कम मामला अंग्रेजी पत्र, (?=.*?[a-z])
• कम से कम एक अंक, (?=.*?[0-9])
• कम से कम एक विशेष चरित्र, (?=.*?[#?!@$%^&*-])
• लंबाई में न्यूनतम आठ .{8,}(एंकर के साथ)

Answer 3

रेग्युलर एक्सप्रेशंस के पास AND ऑपरेटर नहीं होता है, इसलिए रेगेक्स को लिखना काफी मुश्किल होता है, जो वैध पासवर्ड से मेल खाता है, जब वैधता को कुछ और चीजों से परिभाषित किया जाता है और कुछ और ...

लेकिन, नियमित अभिव्यक्तियों में OR ऑपरेटर होता है, इसलिए केवल DeMorgan की प्रमेय लागू करें, और अमान्य पासवर्ड से मेल खाने वाले regex लिखें:

कम से कम आठ वर्ण के साथ कुछ भी या नहीं की संख्या के साथ कुछ भी या नहीं अपरकेस के साथ कुछ भी या या कोई लोअरकेस के साथ कुछ भी या कोई भी विशेष वर्ण के साथ कुछ भी।

इसलिए:

^(.{0,7}|[^0-9]*|[^A-Z]*|[^a-z]*|[a-zA-Z0-9]*)$

अगर कुछ भी मेल खाता है, तो यह एक अमान्य पासवर्ड है।

Comments

ठीक है, मुझे डर था कि आप उन कंप्यूटर वैज्ञानिकों में से एक हैं जिन्हें हम कभी-कभी यह महसूस करते हैं कि नियमित अभिव्यक्ति और रीजैक्स के बीच अंतर नहीं है । ;) यह सच है कि यदि आप मैच के परिणाम की उपेक्षा कर सकते हैं, तो कई रेगेक्स कार्य बहुत सरल हैं, लेकिन यह हमेशा संभव नहीं है। हालांकि यह एक सुंदर रेगेक्स है। यह सरल नहीं है, यह सुरुचिपूर्ण है!

— एलन मूर

मैंने पहले क्यों नहीं सोचा है? शानदार जवाब (जब परिणाम को नकारना संभव हो)

— TeChn4K

यह एक रिक्त स्थान की अनुमति दे रहा है कि कैसे जांच करें कि पासवर्ड में आपके regexp के साथ स्थान नहीं होना चाहिए? मैंने यह कोशिश की / ^( ♥spg.किंग्स0,7जीआईडीएस.ऑनलाइन -ऑनलाइन- I .test ('एएए # ए 1 ए ए'); लेकिन यह काम नहीं कर रहा है

— गौरव

@ गौरव, जोड़ें | [^ \ _] * \ s। *

— मैट टिम्मरमैन

इसे प्यार करना। इसे काम करने के लिए, हालांकि, मुझे इसमें से आखिरी क्लॉज हटाना था |[a-zA-Z0-9]*।

— १-

Answer 4

@ शुभ के जवाब के लिए बस एक छोटा सा सुधार: चूंकि विशेष चरित्र कीबोर्ड में लोगों तक सीमित है, इसलिए किसी विशेष वर्ण के लिए इसका उपयोग करें:

^(?=.*?[A-Z])(?=(.*[a-z]){1,})(?=(.*[\d]){1,})(?=(.*[\W]){1,})(?!.*\s).{8,}$

यह रेगेक्स इन नियमों को लागू करेगा:

• कम से कम एक ऊपरी मामला अंग्रेजी पत्र
• कम से कम एक कम मामला अंग्रेजी पत्र
• कम से कम एक अंक
• कम से कम एक विशेष चरित्र
• लंबाई में न्यूनतम आठ

Comments

जावास्क्रिप्ट स्वाद में, \Wकेवल ASCII वर्णों से मेल खाता है। इसलिए आपने उसे नहीं बदला है, और अब आपको व्हॉट्सएप के पात्रों को फ़िल्टर करना होगा। इसके अलावा, {1,}आपके द्वारा जोड़े गए सभी कोष्ठक और परिमाण शुद्ध शोर हैं, और गैर-लालची ( ?) ऑपरेटरों को हटाना व्यर्थ है। यहां कोई सुधार नहीं हुआ है।

— एलन मूर

और खाली स्ट्रिंग के लिए कैसे बचें। खाली स्ट्रिंग रेगेक्स को वापस लौटना चाहिए। मैंने regex (? =। * [0-9]) (? =। * [Az]) (=? *। * [AZ]) (? =। * * [@ # $% ^ & + =]) का उपयोग किया है। (? = \\ S + $)। {8,15}

— कोडर

_ के लिए विफल रहता है विशेष चरित्र

— अखिलेश

Answer 5

मुझे अपनी परिस्थितियों के लिए सबसे लोकप्रिय जवाब के बाद कुछ कठिनाई हुई। उदाहरण के लिए, मेरी मान्यता जैसे ;या के साथ विफल हो रही थी [। मुझे अपने विशेष पात्रों की श्वेत-सूची में रुचि नहीं थी, इसलिए मैंने इसके बजाय [^\w\s]एक परीक्षण के रूप में लाभ उठाया - बस गैर-शब्द वर्णों (संख्यात्मक सहित) और गैर-सफेद अंतरिक्ष वर्णों का मिलान किया। संक्षेप में, यहाँ मेरे लिए काम किया गया है ...

• कम से कम 8अक्षर
• कम से कम 1संख्यात्मक चरित्र
• कम से कम 1लोअरकेस लेटर
• कम से कम 1अपरकेस अक्षर
• कम से कम 1विशेष चरित्र

---

/^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9])(?=.*?[^\w\s]).{8,}$/

JSFiddle Link - विभिन्न मामलों को कवर करने वाला सरल डेमो

Comments

अच्छा है। लेकिन एक मुद्दा मिला है कि आपकी नियमित अभिव्यक्ति _ (अंडरस्कोर) को एक विशेष चरित्र के रूप में स्वीकार नहीं करेगी :(।

— user3217843

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

— दिनेश.नेट

मैं वास्तव में इस जवाब को पसंद करता हूं सिवाय इसके कि यह अंडरस्कोर स्वीकार नहीं कर सकता। सभी मैंने किया था की जगह था (?=.*?[^\w\s])साथ (?=.*?([^\w\s]|[_]))अंडरस्कोर के लिए समर्थन जोड़ने के लिए और यह अब महान काम करता है। जब हम इसे प्राप्त करते हैं, तो @ Dinish.net सिस्टम मैं व्हाट्सएप का उपयोग पासवर्ड स्ट्रिंग से बाहर करता है, इसलिए यदि आप इस उत्तर का उपयोग करना चाहते हैं तो वेनिला JS String.prototyp.trim () विधि का उपयोग करना बेहतर होगा।

— डेविन कारपेंटर

Answer 6

एक अधिक "जेनेरिक" संस्करण (?), विशेष अक्षरों के रूप में कोई भी अंग्रेजी अक्षरों को अनुमति नहीं देता है ।

^(?=\S*[a-z])(?=\S*[A-Z])(?=\S*\d)(?=\S*[^\w\s])\S{8,}$

var pwdList = [
    '@@V4-\3Z`zTzM{>k',
    '12qw!"QW12',
    '123qweASD!"#',
    '1qA!"#$%&',
    'Günther32',
    '123456789',
    'qweASD123',
    'qweqQWEQWEqw',
    '12qwAS!'
  ],
  re = /^(?=\S*[a-z])(?=\S*[A-Z])(?=\S*\d)(?=\S*[^\w\s])\S{8,}$/;
  
  pwdList.forEach(function (pw) {
    document.write('<span style="color:'+ (re.test(pw) ? 'green':'red') + '">' + pw + '</span><br/>');
  });

Answer 7

जावास्क्रिप्ट फ़ाइल आयात करें jquery.validate.min.js।

आप इस विधि का उपयोग कर सकते हैं:

$.validator.addMethod("pwcheck", function (value) {
    return /[\@\#\$\%\^\&\*\(\)\_\+\!]/.test(value) && /[a-z]/.test(value) && /[0-9]/.test(value) && /[A-Z]/.test(value)
});

1. कम से कम एक ऊपरी मामला अंग्रेजी पत्र
2. कम से कम एक कम मामला अंग्रेजी पत्र
3. कम से कम एक अंक
4. कम से कम एक विशेष चरित्र

Answer 8

इसको आजमाओ:

1. न्यूनतम छह वर्ण
2. कम से कम एक अपरकेस चरित्र
3. कम से कम एक कम चरित्र
4. कम से कम एक विशेष चरित्र

अभिव्यक्ति:

"/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[$@$!%*?&.])[A-Za-z\d$@$!%*?&.]{6, 20}/"

वैकल्पिक विशेष वर्ण:

1. कम से कम एक विशेष चरित्र
2. कम से कम एक नंबर
3. विशेष वर्ण वैकल्पिक हैं
4. न्यूनतम छह वर्ण और अधिकतम 16 वर्ण

अभिव्यक्ति:

"/^(?=.*\d)(?=.*[a-zA-Z]).{6,20}$/"

यदि न्यूनतम और अधिकतम स्थिति की आवश्यकता नहीं है, तो हटा दें .{6, 16}

• 6 न्यूनतम चरित्र सीमा है
• 20 अधिकतम वर्ण सीमा है
• ? = का अर्थ मैच अभिव्यक्ति है

Comments

@ माधु मैंने वैकल्पिक विशेष पात्रों के लिए आपकी स्थिति के लिए अपना जवाब अपडेट किया है

— ओजस कुलकर्णी

Answer 9

सीधे सवाल का जवाब नहीं दे रहा है, लेकिन क्या यह वास्तव में एक रेगीक्स है?

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

इसके अलावा, एक रेगीक्स आमतौर पर एक अनिवार्य या कार्यात्मक समाधान की तुलना में कुछ गुना धीमा होता है।

उदाहरण के लिए, निम्नलिखित (बहुत एफपी नहीं) स्काला फ़ंक्शन सबसे लोकप्रिय उत्तर के रेगेक्स की तुलना में मूल प्रश्न को तीन गुना तेजी से हल करता है। यह क्या करता है यह भी स्पष्ट है कि आपको इकाई परीक्षण की आवश्यकता नहीं है:

def validatePassword(password: String): Boolean = {
  if (password.length < 8)
    return false

  var lower = false
  var upper = false
  var numbers = false
  var special = false

  password.foreach { c =>
    if (c.isDigit)       numbers = true
    else if (c.isLower)  lower = true
    else if (c.isUpper)  upper = true
    else                 special = true
  }

  lower && upper && numbers && special
}

Answer 10

मैं पीटर मोर्टेंसन को जवाब दूंगा, लेकिन मेरे पास पर्याप्त प्रतिष्ठा नहीं है।

उनकी अभिव्यक्तियाँ निर्दिष्ट न्यूनतम आवश्यकताओं में से प्रत्येक के लिए एकदम सही हैं। विशेष वर्णों की आवश्यकता नहीं है कि उनके भावों के साथ समस्या यह है कि वे विशेष वर्ण भी नहीं बनाते हैं, इसलिए वे अधिकतम आवश्यकताओं को भी लागू करते हैं, जो मुझे विश्वास नहीं है कि ओपी ने अनुरोध किया है। आम तौर पर आप अपने उपयोगकर्ताओं को उनके पासवर्ड को उतना ही मजबूत बनाने की अनुमति देना चाहते हैं जितना वे चाहते हैं; क्यों मजबूत पासवर्ड प्रतिबंधित?

तो, उनके "न्यूनतम आठ अक्षर, कम से कम एक अक्षर और एक संख्या" अभिव्यक्ति:

^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$

न्यूनतम आवश्यकता को प्राप्त करता है, लेकिन शेष वर्ण केवल अक्षर और संख्या हो सकते हैं । विशेष वर्णों की अनुमति देने के लिए (लेकिन आवश्यकता नहीं), आपको कुछ का उपयोग करना चाहिए:

^(?=.*[A-Za-z])(?=.*\d).{8,}$ किसी भी वर्ण को अनुमति देने के लिए

या

^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d$@$!%*#?&]{8,}$ विशिष्ट विशेष वर्णों को अनुमति देने के लिए

इसी तरह, "न्यूनतम आठ अक्षर, कम से कम एक अपरकेस लेटर, एक लोअरकेस लेटर और एक नंबर:"

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$

उस न्यूनतम आवश्यकता को पूरा करता है, लेकिन केवल पत्र और संख्या की अनुमति देता है। उपयोग:

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$ किसी भी वर्ण को अनुमति देने के लिए

या

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[A-Za-z\d$@$!%*?&]{8,} विशिष्ट विशेष वर्णों को अनुमति देने के लिए।

Comments

स्पष्टीकरण के लिए धन्यवाद।

— होई गुयेन

इसे सही उत्तर के रूप में चिह्नित किया जाना चाहिए। शीर्ष उत्तर गलत है।

— जेक

Answer 11

Use the following Regex to satisfy the below conditions:

Conditions: 1] Min 1 uppercase letter.
            2] Min 1 lowercase letter.
            3] Min 1 special character.
            4] Min 1 number.
            5] Min 8 characters.
            6] Max 30 characters.

Regex: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[#$@!%&*?])[A-Za-z\d#$@!%&*?]{8,30}$/    

Comments

सालों पहले लिखे गए अन्य उत्तरों की तुलना में आपका उत्तर किस तरीके से बेहतर है?

— जेसेन्टोस १३'१

@ JoshYates1980 आप "विशेष चरित्र" का उल्लेख कर सकते हैं जिसके लिए रेगेक्स आपके लिए विफल रहा। मुझे इसके साथ सत्यापित करने और तदनुसार अद्यतन करने दें। लेकिन जहाँ तक मुझे पता है कि यह 1 विशेष चरित्र की अनिवार्य शर्त के अनुसार काम करता है। आपकी प्रतिक्रिया की प्रतीक्षा में ....

— SHASHANK HONRAO

@SHASHANKHONRAO मैंने अभिव्यक्ति को अद्यतन किया: ^ (? =। * [Az]) (? =। * [AZ]) (=। *। * \ D) (? =? *। * [$ @ $!% *! +?] ~ |{}:;<>/])[A-Za-z\d$@$!%*?&+~| {}:; <> /] {8,15} जिसमें निम्नलिखित नॉनफैल्यूमरिक वर्ण शामिल होंगे (@ $!% *? & + ~ ~ | {}: <> /)

— JoshYates1980

Answer 12

निम्नलिखित रेगेक्स समाधान पर विचार करने के बारे में क्या:

^(?=.*[\w])(?=.*[\W])[\w\W]{8,}$

जो निम्नलिखित को मान्य करता है:

1. कम से कम एक लोअरकेस
2. कम से कम एक अपरकेस
3. कम से कम एक अंक
4. कम से कम एक विशेष चरित्र
5. कम से कम इसमें 8 अक्षर लंबे होने चाहिए।

निम्नलिखित लिंक पर काम करने की जाँच करें https://regex101.com/r/qPmC06/4/

Comments

आपके सुझाए गए रेगेक्स और regex101 लिंक के तहत एक भिन्न होता है। यह नहीं होना चाहिए ^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[\W\_])[A-Za-z\d\W\_]{8,}$?

— क्रेज

@ क्रेज मैंने regex को संपादित किया है, आपके सुझाव के लिए धन्यवाद।

— इमर्सन जोएल रोजास सॉलिज

Answer 13

आपकी जरूरत के अनुसार यह पैटर्न ठीक काम करना चाहिए। इसे इस्तेमाल करे,

^(?=(.*\d){1})(.*\S)(?=.*[a-zA-Z\S])[0-9a-zA-Z\S]{8,}

बस एक स्ट्रिंग वेरिएबल बनाएं, पैटर्न असाइन करें, और एक बूलियन विधि बनाएं जो पैटर्न सही होने पर सही है, अन्यथा गलत।

नमूना:

String pattern = "^(?=(.*\d){1})(.*\S)(?=.*[a-zA-Z\S])[0-9a-zA-Z\S]{8,}";
String password_string = "Type the password here"

private boolean isValidPassword(String password_string) {
    return password_string.matches(Constants.passwordPattern);
}

Answer 14

मुझे यहां कई समस्याएं मिली हैं, इसलिए मैंने अपना खुद का बनाया।

यहाँ यह सभी में है, यह परीक्षण के साथ है:

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*([^a-zA-Z\d\s])).{9,}$

https://regex101.com/r/DCRR65/4/tests

देखने के लिए चीजें:

1. उपयोग नहीं करता है \wक्योंकि इसमें वह शामिल है _, जिसका मैं परीक्षण कर रहा हूं।
2. मुझे रेखाओं के अंत के मिलान के बिना प्रतीकों के मिलान में बहुत सारी परेशानियाँ हैं।
3. विशेष रूप से प्रतीकों को निर्दिष्ट नहीं करता है, यह इसलिए भी है क्योंकि विभिन्न स्थानों पर उनके कीबोर्ड पर अलग-अलग प्रतीक हो सकते हैं जिन्हें वे उपयोग करना चाहते हैं।

Comments

जब सफेद रिक्त स्थान पासवर्ड के अंदर है, तब भी यह रेगेक्स पास होता है, मेरे लिए काम नहीं करता

— आर्थर मेलो

Answer 15

(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+-]).{6}

Comments

अधिक जानकारी के लिए कृपया ज्ञान की

— करें- hubs.blogspot.in/2015/11/…

Answer 16

@ClasG ने पहले ही सुझाव दिया है :

^(?=\S*[a-z])(?=\S*[A-Z])(?=\S*\d)(?=\S*[^\w\s])\S{8,}$

लेकिन यह _ (अंडरस्कोर) को एक विशेष चरित्र के रूप में स्वीकार नहीं करता है (जैसे। Aa12345_)।

एक बेहतर है:

^(?=\S*[a-z])(?=\S*[A-Z])(?=\S*\d)(?=\S*([^\w\s]|[_]))\S{8,}$

Answer 17

डेमो:

function password_check() {
  pass = document.getElementById("password").value;
  console.log(pass);
  regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
  if (regex.exec(pass) == null) {
    alert('invalid password!')
  }
  else {
    console.log("valid");
  }
}

<input type="text" id="password" value="Sample@1">
<input type="button" id="submit" onclick="password_check()" value="submit">

Answer 18

2020 में इस एक का परीक्षण:

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$

अपने आप को सत्यापित करें

const regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
const str = `some12*Nuts`;
let m;

if ((m = regex.exec(str)) !== null) {
    // The result can be accessed through the `m`-variable.
    m.forEach((match, groupIndex) => {
        console.log(`Found match, group ${groupIndex}: ${match}`);
    });
}

Comments

यह स्वीकृत उत्तर से बेहतर कैसे है?

— तोत्तो

@ इस थ्रेड पर कोई स्वीकृत उत्तर नहीं है, कम से कम मुझे कोई दिखाई नहीं देता है, कई वोटों के उत्तर हैं, लेकिन मुझे एक स्वीकृत उत्तर नहीं दिखता है। इसके अलावा मुझे यह पता चला और वैधता के लिए regex101 पर इसके बारे में पढ़ा, इसलिए वैधता को सत्यापित करने के लिए इसे एक कोड स्निपेट के साथ भी साझा किया।

— मिहिर कुमार

Answer 19

नीचे दिए गए शर्तों को पूरा करने के लिए निम्नलिखित Regex का उपयोग करें:

Conditions: 1] Min 1 special character.
            2] Min 1 number.
            3] Min 8 characters or More

regex: ^(?=.*\d)(?=.*[#$@!%&*?])[A-Za-z\d#$@!%&*?]{8,}$

ऑनलाइन टेस्ट कर सकते हैं: https://regex101.com

Answer 20

बस हम HTML5 का उपयोग करके ऐसा कर सकते हैं।

पैटर्न विशेषता में कोड का उपयोग करें,

pattern="(?=^.{8,}$)((?=.*\d)(?=.*\W+))(?![.\n])(?=.*[A-Z])(?=.*[a-z]).*$"

यह पूरी तरह से काम करेगा।

Answer 21

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

((?=.*\\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[~!@#$%^&*()]).{8,20})

Answer 22

(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$

लिंक की जांच ऑनलाइन https://regex101.com/r/mqGurh/1

Answer 23

इसे इस्तेमाल करो,

((?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[!@#$%?=*&]).{8,20})

यह कम से कम एक लोअरकेस, एक अपर केस, एक नंबर और (, @, #, $,%,?, =, *, &) के विशेष चेंजर्स के लिए मान्य होगा।

न्यूनतम लंबाई 8 और अधिकतम लंबाई 20 है

Comments

यह स्वीकृत उत्तर से कैसे भिन्न है?

— टोटो

Answer 24

जावा / एंड्रॉइड में, कम से कम एक नंबर, एक अक्षर, निम्नलिखित पैटर्न में एक विशेष चरित्र के साथ एक पासवर्ड का परीक्षण करने के लिए:

"^(?=.*[A-Za-z])(?=.*\\d)(?=.*[$@$!%*#?&])[A-Za-z\\d$@$!%*#?&]{8,}$"

Answer 25

इसे इस्तेमाल करे:

^.*(?=.{8,})(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])[a-zA-Z0-9@#$%^&+=]*$

यह नियमित अभिव्यक्ति मेरे लिए पूरी तरह से काम करती है।

function myFunction() {
    var str = "c1TTTTaTTT@";
    var patt = new RegExp("^.*(?=.{8,})(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])[a-zA-Z0-9@#$%^&+=]*$");
    var res = patt.test(str);
    console.log("Is regular matches:", res);
}

Answer 26

कम से कम 1 ऊपरी मामले के चरित्र, 1 अंक और किसी विशेष वर्ण और 8 से 63 के बीच की लंबाई से मिलान करने के लिए पैटर्न।

"^ ^! = [az]) (? =) [AZ]) ((=। * \ d) [a-zA-Z \ d \ W] {8,63} $"

इस पैटर्न का उपयोग JAVA प्रोग्रामिंग के लिए किया गया था।

Answer 27

आशा है कि नीचे काम करता है। मैंने एज़्योर कस्टम नीति में यह कोशिश की।

^ ^ (=। [az]) (? (=। [AZ])) (? =। d d) (=! =। @ @ $% ^ & * -_ + = [] {} | \ _ :?? / ~"();!])([A-Za-z\d@#$%^&*\-_+=[\]{}|\\:',?/~ "()!]!] | (!! @)) {6,16} $

Answer 28

मैंने वास्तव में यहां पहले उत्तर की प्रतिलिपि बनाई है और इसे एक अधिक ux-सुविधाजनक regex में बदल दिया है जिसे एक ऊपरी, एक कम और कम से कम 8 वर्णों की आवश्यकता होती है, लेकिन सब कुछ "बीच में" स्वीकार करता है।

यह एक उदाहरण-रेगेक्स है जिसकी आवश्यकता है

1. कम से कम 8 अक्षर की लंबाई
2. कम से कम एक छोटा अक्षर
3. कम से कम एक बड़ा अक्षर

महत्वपूर्ण : यह regex अन्य सभी वर्णों जैसे संख्याओं को छोड़कर, $, # जैसे विशेष वर्णों को भी करेगा! आदि - जब तक नियम 1. से 3. इनपुट स्ट्रिंग से मेल खाते हैं

^(?=.*[a-z])(?=.*[A-Z]).{8,}$

दिमाग लगाओ "।" रेगेक्स के अंत में अलोमस्ट। यह लगभग किसी भी (और पठनीय किसी भी वर्ण) से मेल खाएगा

Answer 29

यदि आप न्यूनतम आठ वर्णों की जांच के लिए नियमित अभिव्यक्तियों का उपयोग करना चाहते हैं, तो कम से कम एक अपरकेस अक्षर, कम से कम एक लोअरकेस अक्षर, कम से कम एक संख्या 0 से 9 तक और कम से कम एक विशेष वर्ण:! @ # $% ^ & * _? और उपयोगकर्ता को पासवर्ड में क्या याद आ रही है, इस बारे में थोड़ी और जानकारी दें, आप निम्नलिखित कोड का उपयोग कर सकते हैं:

let password = "@Aa3a4d$";

//  Check every single condition separately
let lowercase = password.match((/[a-z]+/g));
let uppercase = password.match((/[A-Z]+/g));
let digits = password.match((/[\d]+/g));
let special = password.match((/[!@#$%^&*_]+/g));
let lenght = password.match((/[A-Za-z\d!@#$%^&*_]{8,}/g));

//  Array to store information about any mismatches in the string
let errors = [];

if (password === '' ) {
    errors.push('Password is required');
}
if (lowercase === null) {
    errors.push('Password must include at least one lowercase letter');
}
if (uppercase === null) {
    errors.push('Password must include at least one uppercase letter');
}
if (digits === null) {
    errors.push('Password must include at least one digit from 0 to 9');
}
if (special  === null) {
    errors.push('Password must include at least one special character');
}
if (lenght === null) {
    errors.push('Password must include at least 8 characters');
}
if (errors.length > 0) {
    console.log(errors);
    return;
} else {
    // Process your password
}

Answer 30

एक समाधान जो मुझे पिछले उत्तर में से एक में मिला:

* न्यूनतम 8 अक्षर कम से कम 1 अपरकेस वर्णमाला, 1 लोअरकेस वर्णमाला, 1 संख्या और 1 विशेष वर्ण:

"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[$@$!%*?&])[A-Za-z\d$@$!%*?&]{8,}"*

... मेरे लिए काम नहीं किया, लेकिन निम्नलिखित एक सरलीकृत संस्करण है और महान काम करता है (आप की तरह किसी भी विशेष चरित्र को जोड़ने के लिए, मैंने # यहां जोड़ा), और संख्या नियम को जोड़ें जैसा कि आप अक्षरों के साथ करते हैं:

"^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[$@$!%*?&]){8,}"

Comments

यह एक सकारात्मक रूपांतर की मात्रा निर्धारित कर रहा है।

— ctwheels