रेगेक्स से मेल खाने के लिए आप स्ट्रिंग कैसे बनाते हैं?

Question

मुझे एक स्वरूपण दस्तावेज़ बनाने की आवश्यकता है। मुझे रेगेक्स पता है जो पाठ को प्रारूपित करने के लिए उपयोग किया जाता है लेकिन मुझे नहीं पता कि उस रेगेक्स के लिए एक उदाहरण को पुन: उत्पन्न कैसे किया जाए।

'{\[((?:\#|/)[^ ]*) ([^]]*)\]}' 

किसी को भी एक उदाहरण है कि इस मेल खाएंगे, और हो सकता है यह बताएं कि वह यह मिल गया बनाया जा सकता: यह एक एक आंतरिक लिंक होना चाहिए। मैं '?' पर अटक गया।

मैंने शुरुआत में इस मेटा-कैरेक्टर का कभी भी उपयोग नहीं किया, आमतौर पर मैं इसका उपयोग यह चिह्नित करने के लिए करता हूं कि एक शाब्दिक दिखाई नहीं दे सकता है या बिल्कुल ठीक दिखाई नहीं दे सकता है।

धन्यवाद

Answer 1

(?:...)(...) रूप में एक ही समूह के प्रभाव पड़ता है, लेकिन बिना "कब्जा" समूह की सामग्रियों; http://php.net/manual/en/regexp.reference.subpatterns.php देखें।

तो, (?:\#|/) का अर्थ है "या तो # या /"।

मुझे लगता है कि आप जानते हैं कि [^ ]* का अर्थ है "शून्य या अधिक वर्ण जो एसपी नहीं हैं", और [^]]* का अर्थ है "शून्य या अधिक वर्ण जो दाएं-वर्ग-ब्रैकेट नहीं हैं"।

यह एक साथ रखें, एक संभव स्ट्रिंग यह है:

'{[/abcd asdfasefasdc]}' 

Answer 2

Open source RegexBuddy alternatives और Online regex testing देखें कुछ उपयोगी उपकरणों के लिए। पहले उनके द्वारा एक रेगेक्स समझाया जाना सबसे आसान है। मैं YAPE यहां इस्तेमाल किया:

NODE      EXPLANATION 
---------------------------------------------------------------------- 
    \[      '[' 
---------------------------------------------------------------------- 
    (      group and capture to \1: 
---------------------------------------------------------------------- 
    (?:      group, but do not capture: 
---------------------------------------------------------------------- 
     \#      '#' 
---------------------------------------------------------------------- 
    |      OR 
---------------------------------------------------------------------- 
    /      '/' 
---------------------------------------------------------------------- 
    )      end of grouping 
---------------------------------------------------------------------- 
    [^ ]*     any character except: ' ' (0 or more 
          times (matching the most amount 
          possible)) 
---------------------------------------------------------------------- 
)      end of \1 
---------------------------------------------------------------------- 
          ' ' 
---------------------------------------------------------------------- 
    (      group and capture to \2: 
---------------------------------------------------------------------- 
    [^]]*     any character except: ']' (0 or more 
          times (matching the most amount 
          possible)) 
---------------------------------------------------------------------- 
)      end of \2 
---------------------------------------------------------------------- 
    \]      ']' 
---------------------------------------------------------------------- 

यह अनुमान है कि { और } अपने उदाहरण में regex delimiters हैं किया जा रहा है।

तुम बस स्पष्टीकरण की सूची के माध्यम पढ़ सकते हैं और इस तरह के रूप में एक संभावित स्रोत स्ट्रिंग के साथ आ सकते हैं:

[#NOSPACE NOBRACKET] 

Answer 3

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

जब बहुत सारे मेटाचर्स को अक्षर के रूप में मिलाते हैं, तो
प्रारूप को पढ़ने और आसानी से त्रुटियों से बचने के लिए यह बहुत महत्वपूर्ण है।

यहां पर्ल में कुछ नमूने हैं जो प्रोटोटाइप के लिए आसान (मेरे लिए) थे।

my @samps = (
'{[/abcd asdfasefasdc]}', 
'{[# ]}', 
'{[# /# \/]}', 
'{[/# {[ 
    | /# {[#\/} ]}', 
, 
); 

for (@samps) { 
    if (m~{\[([#/][^ ]*) ([^]]*)\]}~) 
    { 
     print "Found: '$&'\ngrp1 = '$1'\ngrp2 = '$2'\n===========\n\n"; 
    } 
} 

__END__ 

Expanded 

\{\[ 
    (
    [#/][^ ]* 
) 
    [ ] 
    (
    [^\]]* 
) 
\]\} 

आउटपुट

Found: '{[/abcd asdfasefasdc]}' 
grp1 = '/abcd' 
grp2 = 'asdfasefasdc' 
=========== 

Found: '{[# ]}' 
grp1 = '#' 
grp2 = '' 
=========== 

Found: '{[# /# \/]}' 
grp1 = '#' 
grp2 = '/# \/' 
=========== 

Found: '{[/# {[ 
     | /# {[#\/}  ]}' 
grp1 = '/#  {[ 
     |' 
grp2 = '/# {[#\/}  ' 
===========