पासवर्ड की जांच करने के लिए नियमित अभिव्यक्ति है कि "8 अक्षर 1 अपरकेस अक्षर, 1 विशेष वर्ण, अल्फ़ान्यूमेरिक वर्ण सहित"

Question

मैं चाहता हूं कि एक नियमित अभिव्यक्ति की जांच हो

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

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

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

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

Comments

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

— ग्रेग हेविगिल

क्या आपने एक मजबूत पासवर्ड के लिए जाँच करने पर विचार किया है, यह जाँचने के बजाय कि पासवर्ड कुछ मनमाने नियमों को पूरा करता है जो एक मजबूत पासवर्ड के लिए अपूर्ण प्रॉक्सी हैं? पुस्तकालयों और कार्यक्रमों के बहुत सारे हैं जो एक पासवर्ड खिलाए जाने पर, इसकी ताकत का निर्धारण करेंगे।

— वेन कॉनराड

@GregHewgill मैं आपकी टिप्पणी को बढ़ा दूंगा अगर मैं कर सकता था :-) यह "अगर आपके पास एक हथौड़ा है, तो सब कुछ एक नाखून की तरह लगने लगता है"।

— क्रिश्चियन.के

क्या आपको वास्तव में एक अपरकेस / विशेष चरित्र या कम से कम एक की आवश्यकता है?

— mmdemirbas

उपयोगकर्ता की आवश्यकता से, क्या आपका मतलब है कि आपका उपयोगकर्ता कार्यान्वयन विवरण निर्धारित कर रहा है? शायद वे सिर्फ यह खुद कोड करना चाहिए, फिर। सच कहूं, तो मुझे लगता है कि इसे बनाए रखना और समझना आसान होगा अगर आपने सिर्फ काउंटर बनाए और एक-एक कर हर चरित्र की जाँच की, जो कि एक नियम से मेल खाने वाले हर चरित्र के लिए उचित काउंटर बढ़ाता है। एक तकनीकी दृष्टिकोण से यह ऐसा कुछ नहीं है जो किसी को प्रभावित करेगा, लेकिन ऐसी चीज़ के साथ चीजों को जटिल क्यों करें जो त्रुटि-प्रवण और अपडेट करने में कठिन होगा?

Answer 1

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

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

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

आपकी टिप्पणी देखकर, यह है कि मैं इसके बारे में कैसे जाऊंगा:

• आठ वर्ण लंबा होना चाहिए: आपको इसके लिए किसी रेगेक्स की आवश्यकता नहीं है। .Lengthसंपत्ति का उपयोग करना पर्याप्त होना चाहिए।

• एक अपरकेस अक्षर सहित: आप [A-Z]+नियमित अभिव्यक्ति का उपयोग कर सकते हैं । यदि स्ट्रिंग में कम से कम एक ऊपरी अक्षर होता है, तो यह नियमित रूप से अभिव्यक्ति देगा true।

• एक विशेष चरित्र: आप या तो उपयोग कर सकते हैं \Wजो किसी भी वर्ण से मेल खाएगा जो एक अक्षर या संख्या नहीं है या फिर, आप [!@#]विशेष वर्णों की एक कस्टम सूची निर्दिष्ट करने के लिए ऐसा कुछ उपयोग कर सकते हैं । नोट हालांकि इस तरह के रूप कि पात्रों $, ^, (और )इसलिए वे इतनी तरह भाग निकले जाने की जरूरत है, नियमित अभिव्यक्ति भाषा में विशेष वर्ण हैं: \$। तो संक्षेप में, आप का उपयोग कर सकते हैं \W।

• अक्षरांकीय वर्ण: \w+किसी अक्षर और संख्या और अंडरस्कोर से मेल खाना चाहिए।

पर एक नजर डालें इस बारे में अधिक जानकारी के लिए ट्यूटोरियल।

Comments

मैंने यह नहीं लिखा है कि मेरा स्वयंवर मुझे Google प्रिय मित्र से प्राप्त हो

— Rania Umair

@RaniaUmair: मुझे लगता है कि आपकी टिप्पणी मेरी बात साबित करती है। मैं आपको सलाह दूंगा कि आप इसे वैसे ही तोड़ दें जैसे मैंने निर्दिष्ट किया है।

— npinti

+1 रेगेक्स शक्तिशाली है, लेकिन ब्रह्मांड में किसी भी समस्या को हल करने के लिए नहीं था

— क्रिश्चियन लुपस्कु

@ w0lf: मैं अधिक सहमत नहीं हो सका। रेगेक्स शक्तिशाली है, हालांकि, यह बहुत अधिक जटिल हो जाता है, इसलिए बेहतर है कि इसे सरल रखें।

— नपंती

क्या आप मेरी मदद कर सकते हैं मुझे एक ऐसे रेक्स की जरूरत है जो कम से कम एक नंबर स्वीकार करे और अधिकतम 3 अन्य चेंजर्स कुछ भी हो

— Lijo

Answer 2

(                   # Start of group
    (?=.*\d)        #   must contain at least one digit
    (?=.*[A-Z])     #   must contain at least one uppercase character
    (?=.*\W)        #   must contain at least one special symbol
       .            #     match anything with previous condition checking
         {8,8}      #        length is exactly 8 characters
)                   # End of group

एक पंक्ति में:

((?=.*\d)(?=.*[A-Z])(?=.*\W).{8,8})

संपादित करें 2019-05-28:

आपको पूरे इनपुट स्ट्रिंग से मिलान करना होगा। इसलिए, आप पूर्ण इनपुट के रूप में गलती से आंशिक मिलान मानने से रोकने ^और बीच में रेगेक्स को संलग्न कर सकते हैं $:

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

सूत्रों का कहना है:

• पासवर्ड मिलान अभिव्यक्ति

• पासवर्ड एक्सपट्र्स वैलिडेशन विद रेग्युलर एक्सप्रेशंस

Comments

क्योंकि इसमें 12 अक्षर होते हैं

— mmdemirbas

एक और शर्त एक अंक से शुरू नहीं होनी चाहिए मैं यह कैसे कर सकता हूं?

— लीजो

आप 8 वर्णों के बजाय {8} का उपयोग करके इसे छोटा कर सकते हैं

— एंजेलो ट्रिकारिको

$ 1eerrrrrr के लिए इसका मिलान .. इसका कोई बड़ा अक्षर नहीं है।

— शिल्पी जायसवाल

@ शिल्पीजैसवाल या तो आप केस-असंवेदनशील मैच के लिए एक ध्वज का उपयोग कर रहे हैं, या "मैच" के बजाय "खोज" बना रहे हैं। यह सुनिश्चित करने के लिए कि आप पूरे इनपुट स्ट्रिंग से मेल खा रहे हैं, आप रेगेक्स को बीच में ^और घेर सकते हैं $। इसे ^((?=.*\d)(?=.*[A-Z])(?=.*\W).{8,8})$

— आजमाइए

Answer 3

इतने सारे उत्तर .... सब बुरा!

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

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

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

इसलिए:

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

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

Comments

यदि ओपी ठीक 8 वर्ण चाहता था, तो आपको जोड़ना होगा |.{9,}। अवधारणा के लिए +1

— डैनियल

प्रश्न के लिए महान और सरल समाधान, हालांकि मैं मानता हूं कि एक एकल नियमित अभिव्यक्ति वास्तविक समस्या के लिए इष्टतम नहीं है।

— सिडराइट Zackwehdex

रेग्युलर एक्सप्रेशंस करते है और ऑपरेटरों, वे अग्रदर्शी / lookbehind दावे कहा जाता है।

— अपेक्षाकृत_ब्रांड

Answer 4

इसका उत्तर नियमित अभिव्यक्ति का उपयोग नहीं करना है। यह सेट और गिनती है।

नियमित अभिव्यक्ति आदेश के बारे में हैं।

एक प्रोग्रामर के रूप में आपके जीवन में आपको कई ऐसे काम करने के लिए कहा जाएगा जिनका कोई मतलब नहीं है। एक स्तर गहरा खोदना सीखें। जब प्रश्न गलत हो तो जानें।

प्रश्न (यदि यह नियमित अभिव्यक्ति का उल्लेख करता है) गलत है।

स्यूडोकोड (देर से, बहुत सारी भाषाओं के बीच स्विच हो रहा है):

if s.length < 8:
    return False
nUpper = nLower = nAlphanum = nSpecial = 0
for c in s:
    if isUpper(c):
        nUpper++
    if isLower(c):
        nLower++
    if isAlphanumeric(c):
        nAlphanum++
    if isSpecial(c):
        nSpecial++
return (0 < nUpper) and (0 < nAlphanum) and (0 < nSpecial)

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

यह भी ध्यान दें कि प्रश्न स्पष्ट रूप से संक्षिप्त है। चरित्र ASCII या यूनिकोड सेट है, या ?? प्रश्न पढ़ने से मेरा अनुमान है कि कम से कम एक लोअरकेस वर्ण मान लिया गया है। इसलिए मुझे लगता है कि अंतिम नियम होना चाहिए:

return (0 < nUpper) and (0 < nLower) and (0 < nAlphanum) and (0 < nSpecial)

(सुरक्षा-केंद्रित करने के लिए टोपी बदलना, यह वास्तव में कष्टप्रद है / उपयोगी नियम नहीं है।)

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

Comments

मैं सहमत हूँ। जितने अधिक लोगों के साथ आप काम करते हैं, उतने कोड को पठनीय होने की आवश्यकता होती है, हालांकि कुछ regexp कार्यान्वयन जो मैंने उत्तर के रूप में देखा, वे स्पष्ट हैं

— निकोला पेलुचेती

मुझे यह पसंद है कि आप जैसे कुछ उपयोगकर्ता यह कहने की हिम्मत रखते हैं कि रेगेक्स हमेशा लागू करने के लिए बेहतर समाधान नहीं है और कुछ समय में, सरल प्रोग्रामिंग अधिक पठनीय है।

— श्वेले

Answer 5

एक उदाहरण के रूप में यह एक पठनीय / बनाए रखने योग्य रेगेक्स के साथ कैसे किया जा सकता है।

लंबे समय तक रेगेक्स के लिए आपको हमेशा RegexOptions.IgnorePatternWhitespaceबेहतर पठनीयता के लिए अभिव्यक्ति में व्हाट्सएप और टिप्पणियों की अनुमति देने के लिए उपयोग करना चाहिए ।

String[] passwords = { "foobar", "Foobar", "Foobar1", "Fooobar12" };

foreach (String s in passwords) {

    Match password = Regex.Match(s, @"
                                      ^              # Match the start of the string
                                       (?=.*\p{Lu})  # Positive lookahead assertion, is true when there is an uppercase letter
                                       (?=.*\P{L})   # Positive lookahead assertion, is true when there is a non-letter
                                       \S{8,}        # At least 8 non whitespace characters
                                      $              # Match the end of the string
                                     ", RegexOptions.IgnorePatternWhitespace);

    if (password.Success) {
        Console.WriteLine(s + ": valid");
    }
    else {
        Console.WriteLine(s + ": invalid");
    }
}

Console.ReadLine();

Comments

यह lookahead assertionएक एकल रेगेक्स के भीतर पूरे बाधा को कवर करने के लिए "और" पैटर्न के रूप में दुरुपयोग करने का सबसे अच्छा तरीका है । अधिक बाधाओं के लिए काम करता है और आसानी से उत्पन्न किया जा सकता है अगर कुछ बाधाओं को कॉन्फ़िगरेशन द्वारा सक्षम / अक्षम किया जाना चाहिए।

— dognose

यूनिकोड श्रेणियों का उपयोग एक उत्कृष्ट विचार है। दुनिया ASCII से व्यापक है!

— वाल्टर ट्रॉस

Answer 6

यदि आपको केवल एक ऊपरी मामले और विशेष चरित्र की आवश्यकता है तो यह काम करना चाहिए:

@"^(?=.{8,}$)(?=[^A-Z]*[A-Z][^A-Z]*$)\w*\W\w*$"

Comments

AAaaaaaaa#इस अभिव्यक्ति के अनुसार स्ट्रिंग ठीक नहीं है

— क्रिस्टियान लुपस्कु

खैर, यह 10 है, 8 वर्ण लंबा नहीं है और बाद में एक से अधिक ऊपरी मामले हैं, इसलिए यह विफल होना चाहिए ...

— user1096188

आप सही हैं, यह करता है प्रश्न में यह कहने। मुझे लगा कि ये नियम "बिल्कुल एक अपरकेस" के बजाय "कम से कम एक अपरकेस" जैसे थे । मुझे यकीन नहीं है कि यह वही है जो ओपी चाहता था।

— क्रिस्टियान लुपस्कू

Answer 7

नियमित अभिव्यक्ति आप के लिए देख रहा था है: /^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#\$%\^&\*\[\]"\';:_\-<>\., =\+\/\\]).{8,}$/u।

उदाहरण और परीक्षण: http://regexr.com/3fhr4

Comments

रिक्त स्थान की अनुमति है

— Swimburger

@sniels बस बदलने .से पहले {8,}करने के लिए [^\s]।

— लुकास सिल्वा

Answer 8

यह सवाल वायरल होने लगा और काफी दिलचस्प सुझाव सामने आए।

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

यह लिंक दिलचस्प हो सकता है: एक स्ट्रिंग , रेगुलर एक्सप्रेशन लैंग्वेज , कैप्चरिंग ग्रुप्स में किसी भी क्रम में कम से कम 2 अंकों के 2 अक्षरों का मिलान करें

मैं इस टेम्पलेट का उपयोग कर रहा हूँ (?=(?:.*?({type})){({count})})जो मैंने एसओ में देखे गए सभी रेगेक्स पर आधारित है। अगला चरण आवश्यक पैटर्न ( number, special character...) की जगह ले रहा है और लंबाई के लिए कॉन्फ़िगरेशन जोड़ रहा है।

मैंने regex PasswordRegexGenerator.cs की रचना के लिए एक छोटा वर्ग बनाया है। एक उदाहरण:

string result = new PasswordRegexGenerator ( )
        .UpperCase ( 3, -1 )    // ... {3,}
        .Number ( 2, 4 )        // ... {2,4}
        .SpecialCharacter ( 2 ) // ... {2}
        .Total ( 8,-1 )
        .Compose ( );

/// <summary>
/// Generator for regular expression, validating password requirements.
/// </summary>
public class PasswordRegexGenerator
{
    private string _elementTemplate = "(?=(?:.*?({type})){({count})})";

    private Dictionary<string, string> _elements = new Dictionary<string, string> {
        { "uppercase", "[A-Z]" },
        { "lowercase", "[a-z]" },
        { "number", @"\d" },
        { "special", @"\W" },
        { "alphanumeric", @"\w" }
    };

    private StringBuilder _sb = new StringBuilder ( );

    private string Construct ( string what, int min, int max )
    {
        StringBuilder sb = new StringBuilder ( _elementTemplate );
        string count = min.ToString ( );

        if ( max == -1 )
        {
            count += ",";
        }
        else if ( max > 0 )
        {
            count += "," + max.ToString();
        }

        return sb
            .Replace ( "({type})", what )
            .Replace ( "({count})", count )
            .ToString ( );
    }

    /// <summary>
    /// Change the template for the generation of the regex parts
    /// </summary>
    /// <param name="newTemplate">the new template</param>
    /// <returns></returns>
    public PasswordRegexGenerator ChangeRegexTemplate ( string newTemplate )
    {
        _elementTemplate = newTemplate;
        return this;
       }

    /// <summary>
    /// Change or update the regex for a certain type ( number, uppercase ... )
    /// </summary>
    /// <param name="name">type of the regex</param>
    /// <param name="regex">new value for the regex</param>
    /// <returns></returns>
    public PasswordRegexGenerator ChangeRegexElements ( string name, string regex )
    {
        if ( _elements.ContainsKey ( name ) )
        {
            _elements[ name ] = regex;
        }
        else
        {
            _elements.Add ( name, regex );
        }
        return this;
    }

    #region construction methods 

    /// <summary>
    /// Adding number requirement
    /// </summary>
    /// <param name="min"></param>
    /// <param name="max"></param>
    /// <returns></returns>
    public PasswordRegexGenerator Number ( int min = 1, int max = 0 )
    {
        _sb.Append ( Construct ( _elements[ "number" ], min, max ) );
        return this;
    }

    public PasswordRegexGenerator UpperCase ( int min = 1, int max = 0 )
    {
        _sb.Append ( Construct ( _elements[ "uppercase" ], min, max ) );
        return this;
    }

    public PasswordRegexGenerator LowerCase ( int min = 1, int max = 0 )
    {
        _sb.Append ( Construct ( _elements[ "lowercase" ], min, max ) );
        return this;
    }

    public PasswordRegexGenerator SpecialCharacter ( int min = 1, int max = 0 )
    {
        _sb.Append ( Construct ( _elements[ "special" ], min, max ) );
        return this;
    }

    public PasswordRegexGenerator Total ( int min, int max = 0 )
    {
        string count = min.ToString ( ) + ( ( max == 0 ) ? "" : "," + max.ToString ( ) );
        _sb.Append ( ".{" + count + "}" );
        return this;
    }

    #endregion

    public string Compose ()
    {
        return "(" + _sb.ToString ( ) + ")";
    }
}

Answer 9

सत्यापन के लिए आप निम्न श्रेणी का उपयोग कर सकते हैं:

public class PasswordValidator{

  private Pattern pattern;
  private Matcher matcher;

  private static final String PASSWORD_PATTERN =
          "((?=.*\\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%]).{6,20})";

  public PasswordValidator(){
      pattern = Pattern.compile(PASSWORD_PATTERN);
  }

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

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

  }
}

जहां 6 और 20 पासवर्ड के लिए न्यूनतम और अधिकतम लंबाई है।

Answer 10

• पहले पूरे पासवर्ड से मेल खाने के लिए एक नॉनबैकट्रैकिंग अभिव्यक्ति का उपयोग करें, अगर इसमें कम से कम 8 अक्षर हैं (इस तरह, लंबे समय तक दहनशील विस्फोट नहीं होता है, लेकिन अमान्य पासवर्ड): (?>{8,})
• सभी आवश्यक पात्रों (और-स्थितियों) की उपस्थिति की जांच करने के लिए लुकअप एब्सर्ड का उपयोग करें। (?<=...)
• कम से कम एक अपरकेस चरित्र: (?<=\p{Lu}.*)
• कम से कम एक विशेष चरित्र (थोड़ा अस्पष्ट, लेकिन चलो शब्द नहीं का उपयोग करें): (?<=\W.*)
• कम से कम एक अल्फ़ान्यूमेरिक वर्ण (: (?<=\w.*)

सारांश पेश करना:

(?>.{8,})(?<=\p{Lu}.*)(?<=\W.*)(?<=\w.*)

Answer 11

सबसे अच्छा सब कुछ के लिए regex का उपयोग नहीं कर रहा है। वे आवश्यकताएं बहुत हल्की हैं। सीपीयू-वार स्ट्रिंग ऑपरेशन पर मानदंड / सत्यापन की जाँच करना रेगेक्स की तुलना में बहुत सस्ता और तेज़ है!

Answer 12

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

Comments

मेरा सुझाव है कि आप अपने प्रश्न को संपादित करें और कुछ स्पष्टीकरण शामिल करें। कोड-केवल उत्तर कभी-कभी बहुत अच्छे होते हैं, लेकिन कोड + स्पष्टीकरण उत्तर हमेशा बेहतर होते हैं

— बैरनका