सी # Regex.ly घुंघराले ब्रैकेट्स- केवल सामग्री? (ब्रेसिज़ को छोड़ दें)

Question

मैं इस पर कोई जवाब नहीं ढूंढ पाया: क्या मैं विधि का उपयोग कर सामग्री घुंघराले ब्रेसिज़ वाले आइटमों को वापस करने के लिए कर सकता हूं?

यदि मैं रेगेक्स ({[^}]*}) का उपयोग करता हूं तो मेरे MatchCollection मूल्यों में ब्रेसिज़ शामिल हैं। मैं मिलान करना चाहता हूं, लेकिन फिर केवल सामग्री लौटाना चाहता हूं। यहाँ मैं अब तक है:

Regex regex = new Regex(({[^}]*}), RegexOptions.IgnoreCase); 
MatchCollection matches = regex.Matches("Test {Token1} {Token 2}"); 
// Results include braces (undesirable) 
var results = matches.Cast<Match>().Select(m => m.Value).Distinct().ToList(); 

Answer 1

मुझे हमेशा यह स्पष्ट पसंद आया।

(?<=\{) 
[^}]* 
(?=\}) 

जिसका अर्थ है:: तो आप "सकारात्मक lookbehind" (? < = ...) और "सकारात्मक अग्रदर्शी" (? = ...) समूहों का उपयोग कर सकते

• धनुषाकार कोष्ठक खोलने की आवश्यकता होती है से पहले मैच
• (बेशक,) कलेक्ट पाठ - के रूप में इससे पहले कि मैं हो सकता है टिप्पणी की थी [^ {}] * साथ ही
• मैच के बाद धनुषाकार कोष्ठक बंद करने की आवश्यकता होती है

Answer 2

बस कोष्ठकों के बाहर ले जाने के ब्रेसिज़:

{([^}]*)} 

Answer 3

तो मैं समझता हूँ कि आप क्या चाहते हैं। Regex को {([^}]*)} पर बदलें। यह केवल {} के बीच पाठ को कैप्चर करेगा, जिसमें उन्हें शामिल नहीं किया जाएगा।

Answer 4

धन्यवाद मिलोज़ क्रेज्यूस्की, कुछ भी नहीं जोड़ते हैं, लेकिन यहां के समारोह

private List<String> GetTokens(String str) 
{ 
    Regex regex = new Regex(@"(?<=\{)[^}]*(?=\})", RegexOptions.IgnoreCase); 
    MatchCollection matches = regex.Matches(str); 

    // Results include braces (undesirable) 
    return matches.Cast<Match>().Select(m => m.Value).Distinct().ToList(); 
} 

Answer 5

यह सी # .net के लिए regex है।

@"{(.*?)}" 

इसे प्रदर्शित एक

token1 token2

Answer 6

सी # में, कई अन्य प्रोग्रामिंग भाषा के रूप में, regex इंजन कब्जा समूहों, कि submatches हैं का समर्थन करता है, के कुछ हिस्सों सबस्ट्रिंग जो पूरे रेगेक्स पैटर्न से मेल खाते हैं, कोष्ठक की सहायता से रेगेक्स पैटर्न में परिभाषित किया गया है (उदाहरण के लिए 1([0-9])3से मेल खाता है 10 और 2 के मान को कैप्चर समूह 1 बफर में सहेजें)। कैप्चर किए गए ग्रंथों को Match.Groups[n].Value के माध्यम से एक्सेस किया जाता है जहां n पैटर्न के अंदर कैप्चर समूह की अनुक्रमणिका है।

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

रेगेक्सहेरो में किए गए मेरे रेगेक्स स्पीड टेस्ट को देखें।शुद्ध:

अब, हम कैसे घुंघराले ब्रेसिज़ अंदर-स्ट्रिंग मिल सकता है?

• अगर वहाँ एक नकार चरित्र वर्ग है कोई अन्य घुंघराले ब्रेसिज़ के अंदर साथ,: {([^{}]*)
• अगर वहाँ नेस्ट किया जा सकता है कर्ली कोष्ठक: {((?>[^{}]+|{(?<c>)|}(?<-c>))*(?(c)(?!)))

दोनों ही मामलों में, हम एक उद्घाटन मैच {, और उसके बाद { या } के अलावा किसी भी चरित्र से मिलान करें, या (2) पहले वर्णित } तक के किसी भी वर्ण। , Token1, Token {2}Token1, Token 2:

यहाँ sample code है:

var matches = Regex.Matches("Test {Token1} {Token 2}", @"{([^{}]*)"); 
var results = matches.Cast<Match>().Select(m => m.Groups[1].Value).Distinct().ToList(); 
Console.WriteLine(String.Join(", ", results)); 
matches = Regex.Matches("Test {Token1} {Token {2}}", @"{((?>[^{}]+|{(?<c>)|}(?<-c>))*(?(c)(?!)))"); 
results = matches.Cast<Match>().Select(m => m.Groups[1].Value).Distinct().ToList(); 
Console.WriteLine(String.Join(", ", results)); 

परिणाम।

ध्यान दें कि RegexOptions.IgnoreCase अनावश्यक है जब आपके पास कोई शाब्दिक अक्षर नहीं है जिसमें पैटर्न में अलग-अलग मामले हो सकते हैं।