RegEx एक पैटर्न से मिलान करने के लिए, जब तक कि यह एक अलग पैटर्न

Question

से पहले नहीं है, मुझे टेक्स्ट प्रतिस्थापन के लिए उपयोग की जाने वाली रेगेक्स की आवश्यकता है। उदाहरण: मिलान करने वाला टेक्स्ट ABC (जिसे स्क्वायर ब्रैकेट से घिराया जा सकता है), प्रतिस्थापन टेक्स्ट DEF है। यह काफी बुनियादी है। जटिलता यह है कि मैं ABC पाठ से पहले \[[\d ]+\]\. पैटर्न से पहले मिलान करना चाहता हूं - दूसरे शब्दों में, जब यह किसी शब्द या ब्रैकेट में शब्दों के सेट से पहले होता है, उसके बाद अवधि होती है।

यहाँ स्रोत पाठ के कुछ उदाहरण मिलान किया जा, और परिणाम है, के बाद regex प्रतिस्थापन किया जाएगा:

1. [xxx xxx].[ABC] > [xxx xxx].[ABC] (does not match - first part fits the pattern) 
2. [xxx xxx].ABC > [xxx xxx].ABC (does not match - first part fits the pattern) 
3. [xxx.ABC  > [xxx.DEF  (matches - first part has no closing bracket) 
4. [ABC]   > [DEF]   (matches - no first part) 
5. ABC    > DEF    (matches - no first part) 
6. [xxx][ABC]  > [xxx][DEF]  (matches - no period in between) 
7. [xxx]. [ABC] > [xxx] [DEF]  (matches - space in between) 

क्या यह करने के लिए नीचे आता है: मैं कैसे पूर्ववर्ती पैटर्न निर्दिष्ट कर सकते हैं कि जब वर्णित के रूप में मौजूद एक मैच को रोक देगा? इस मामले में पैटर्न क्या होगा? (सी # रेगेक्स का स्वाद)

Answer 1

आप नकारात्मक दिखने वाली अभिव्यक्ति चाहते हैं। ये (?<!pattern) की तरह लग रही है, तो:

(?<!\[[\d ]+\]\.)\[?ABC\]? 

ध्यान दें कि यह एबीसी चारों ओर वर्गाकार कोष्ठकों का मिलान जोड़ी के लिए मजबूर नहीं करता है; यह सिर्फ एक वैकल्पिक खुले ब्रैकेट के लिए और एक वैकल्पिक बंद ब्रैकेट के बाद अनुमति देता है।

(?<!\[[\d ]+\]\.)(?:ABC|\[ABC\]) 

यह गैर पर कब्जा करने कोष्ठकों का उपयोग करता प्रत्यावर्तन परिसीमित करने के लिए: यदि आप एक मिलान जोड़ी या कोई भी मजबूर करने के लिए चाहते हैं तो आपके प्रत्यावर्तन का उपयोग करना होगा। यदि आप वास्तव में एबीसी को कैप्चर करना चाहते हैं, तो आप इसे कैप्चर ग्रुप में बदल सकते हैं।

ईटीए: कारण पहली अभिव्यक्ति असफल रहा है कि यह ABC], जो निषिद्ध पाठ से पहले नहीं किया गया है पर मिलान किया जाता है। ओपन ब्रैकेट [ वैकल्पिक है, इसलिए यह उससे मेल नहीं खाता है। इस के आसपास जिस तरह से नकारात्मक लुक-पीछे दावे में वैकल्पिक खुला ब्रैकेट [ शिफ्ट करने के लिए है, इसलिए की तरह है:

(?<!\[[\d ]+\]\.\[?)ABC\]? 

यह क्या से मेल खाता है का एक उदाहरण और नहीं करता है: करने की कोशिश कर

[123].[ABC]: fail (expected: fail) 
[123 456].[ABC]: fail (expected: fail) 
[123.ABC: match (expected: match) 
    matched: ABC 
ABC: match (expected: match) 
    matched: ABC 
[ABC]: match (expected: match) 
    matched: ABC] 
[ABC[: match (expected: fail) 
    matched: ABC 

के रूप में दूसरा पैटर्न का इरादा, एक खुला ब्रैकेट [ बल एक मिलान करीब ब्रैकेट ] की उपस्थिति बनाने के लिए, जटिल काम है, लेकिन यह काम करने के लिए लगता है:

(?:(?<!\[[\d ]+\]\.\[)ABC\]|(?<!\[[\d ]+\]\.)(?<!\[)ABC(?!\])) 

यह क्या से मेल खाता है और नहीं है का एक उदाहरण:

[123].[ABC]: fail (expected: fail) 
[123 456].[ABC]: fail (expected: fail) 
[123.ABC: match (expected: match) 
    matched: ABC 
ABC: match (expected: match) 
    matched: ABC 
[ABC]: match (expected: match) 
    matched: ABC] 
[ABC[: fail (expected: fail) 

उदाहरण इस कोड का उपयोग उत्पन्न किया गया: स्ट्रिंग "के बाद"

// Compile and run with: mcs so_regex.cs && mono so_regex.exe 
using System; 
using System.Text.RegularExpressions; 

public class SORegex { 
    public static void Main() { 
    string[] values = {"[123].[ABC]", "[123 456].[ABC]", "[123.ABC", "ABC", "[ABC]", "[ABC["}; 
    string[] expected = {"fail", "fail", "match", "match", "match", "fail"}; 
    string pattern = @"(?<!\[[\d ]+\]\.\[?)ABC\]?"; // Don't force [ to match ]. 
    //string pattern = @"(?:(?<!\[[\d ]+\]\.\[)ABC\]|(?<!\[[\d ]+\]\.)(?<!\[)ABC(?!\]))"; // Force balanced brackets. 
    Console.WriteLine("pattern: {0}", pattern); 
    int i = 0; 
    foreach (string text in values) { 
     Match m = Regex.Match(text, pattern); 
     bool isMatch = m.Success; 
     Console.WriteLine("{0}: {1} (expected: {2})", text, isMatch? "match" : "fail", expected[i++]); 
     if (isMatch) Console.WriteLine("\tmatched: {0}", m.Value); 
    } 
    } 
}