Regex केवल संख्याओं वाले वर्ग कोष्ठक मिलता है लेकिन इस वर्गाकार कोष्ठक में नहीं हैं खुद को

Question

नमूना स्ट्रिंग

"[] [ds*[000112]] [1448472995] sample string [1448472995] ***"; 

regex

[1448472995] [1448472995] 

से मेल खाना चाहिए और [000112] मेल नहीं खाना चाहिए क्योंकि वहाँ बाहरी वर्ग है ब्रैकेट।

वर्तमान में मैं इस regex कि [000112] रूप में अच्छी तरह

const string unixTimeStampPattern = @"\[([0-9]+)]"; 

Answer 1

यह संतुलित पाठ का उपयोग कर यह करने के लिए एक अच्छा तरीका है।

(\[ \d+ \])     # (1) 
|        # or, 
    \[       # Opening bracket 
    (?>       # Then either match (possessively): 
     [^\[\]]+      # non - brackets 
     |        # or 
     \[       # [ increase the bracket counter 
     (?<Depth>) 
     |        # or 
     \]       # ] decrease the bracket counter 
     (?<-Depth>) 
    )*       # Repeat as needed. 
    (?(Depth)      # Assert that the bracket counter is at zero 
     (?!) 
    ) 
    \]       # Closing bracket 

सी # नमूना

string sTestSample = "[] [ds*[000112]] [1448472995] sample string [1448472995] ***"; 
Regex RxBracket = new Regex(@"(\[\d+\])|\[(?>[^\[\]]+|\[(?<Depth>)|\](?<-Depth>))*(?(Depth)(?!))\]"); 

Match bracketMatch = RxBracket.Match(sTestSample); 
while (bracketMatch.Success) 
{ 
    if (bracketMatch.Groups[1].Success) 
     Console.WriteLine("{0}", bracketMatch); 
    bracketMatch = bracketMatch.NextMatch(); 
} 

आउटपुट

[1448472995] 
[1448472995] 

Answer 2

मिलान अपेक्षा के अनुसार यह आपकी अभिव्यक्ति से मेल खाएगी है: http://regexr.com/3csg3 यह अग्रदर्शी उपयोग करता है।

Answer 3

आप इस संभाल करने balancing groups उपयोग करने की आवश्यकता - यह थोड़ा कठिन दिखता है, लेकिन यह सब जटिल नहीं है:

Regex regexObj = new Regex(
    @"\[    # Match opening bracket. 
    \d+    # Match a number. 
    \]     # Match closing bracket. 
    (?=    # Assert that the following can be matched ahead: 
    (?>    # The following group (made atomic to avoid backtracking): 
     [^\[\]]+   # One or more characters except brackets 
    |     # or 
     \[ (?<Depth>) # an opening bracket (increase bracket counter) 
    |     # or 
     \] (?<-Depth>) # a closing bracket (decrease bracket counter, can't go below 0). 
    )*    # Repeat ad libitum. 
    (?(Depth)(?!)) # Assert that the bracket counter is now zero. 
    [^\[\]]*   # Match any remaining non-bracket characters 
    \z    # until the end of the string. 
    )     # End of lookahead.", 
    RegexOptions.IgnorePatternWhitespace); 

Answer 4

तुम सिर्फ यूनिक्स समय स्टाम्प पर कब्जा करने की कोशिश कर रहे हैं? फिर आप एक सरल कोशिश कर सकते हैं जहां आप समूह में मिलान किए गए वर्णों की न्यूनतम संख्या निर्दिष्ट करते हैं।

\[([0-9]{10})\] 

यहाँ मैं 10 अक्षर तक सीमित के बाद से मुझे शक समय स्टाम्प कभी भी जल्द ही 11 अक्षर मारा जाएगा ... कि के खिलाफ की रक्षा करने के लिए:

\[([0-9]{10,11})\] 

बेशक इस झूठे सकारात्मक है, तो करने के लिए ले जा सकता है आपके पास एक संलग्न ब्रैकेट में 10-लंबाई की संख्या है।