"[" "]" - regex द्वारा संलग्न किए जाने के अलावा संख्याओं की पहचान करने के लिए Regex

मैं एक regex लिखना चाहता हूं जैसे कि मैं केवल वर्ग कोष्ठक द्वारा संलग्न पहली संख्या से मेल खाता हूं।

जैसे asdadsas,*&(*&(*2asdasd*U(*&*()&(*3 2 (कोई वर्ग कोष्ठक) से मेल खाना चाहिए

तथा asdadsas,*&(*&(*[2]asdasd*U(*&*()&(*3 3 से मेल खाना चाहिए

मेरे पास अब तक का रेगेक्स है: (?<![)[0-9](?!])

हालाँकि, मेरे पास समस्या यह है कि [2 अभी भी 2 से मेल खाना चाहिए।

मैं केवल संख्या को छोड़ना चाहता हूं यदि उसमें ए है [ बाईं ओर और ए ] दांई ओर।

मैं नहीं जानता कि कैसे (या यदि इसके भी संभव हो) इस तरह के सशर्त तर्क को रेगेक्स में लागू करने के लिए।

उत्तर:

जवाब के लिए 2 № 1

निम्नलिखित कार्य करना चाहिए:

[0-9](?!(?<=[.)])

उदाहरण: http://rubular.com/r/0vKy8hyMy0

स्पष्टीकरण: [0-9] एक अंक से मेल खाता है, (?!(?<=[.)]) उस आवश्यकता को लागू करता है जो उस अंक से पहले और उसके बाद का चरित्र नहीं है [ तथा ] क्रमशः। इसे तोड़ने के लिए, निम्नलिखित रेगेक्स पर विचार करें:

(?<=[.)]

इसे "मैच ए" के रूप में पढ़ा जा सकता है ] लेकिन केवल अगर चरित्र दो जगह पहले एक था ["अंक के मिलान के ठीक बाद इसे नकारात्मक रूप में देखने से, यदि चरित्र दो जगह पहले था तो हम विफल हो सकते हैं [ और अगला चरित्र ए है ].

---

जवाब के लिए 0 № 2

(?!    # start negative lookahead
[ # open bracket
d # digit (use d+ if needed)
] # close bracket
)      # end negative lookahead
[     # literal bracket
(d)   # capture digit
|      # alternation (OR)
(?<!   # start negative lookbehind
[     # literal bracket
)
(d)   # capture digit

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

http://rubular.com/r/C8YSRiY1d0

---

जवाब के लिए 0 № 3

मेरा मानना ​​है कि आपके लिए सबसे सरल रेगेक्स है:

(?<![)[0-9]+|[0-9]+(?!])

लाइव डेमो: http://www.rubular.com/r/xWXFg7QXZJ

---

जवाब के लिए 0 № 4

लुक-अराउंड और अल्टरनेशन का उपयोग करके देखें। यह या तो एक अंक से मेल खाता है जो पहले नहीं था [ या एक अंक द्वारा पीछा नहीं किया ]:

(?<![)d|d(?!])

इसके लिए एक से अधिक अंकों की संख्या के साथ काम करने के लिए, आपको "पिछले / अगले चरित्र को सुनिश्चित करने के लिए लुक-अराउंड जोड़ने की आवश्यकता है न तो एक ब्रैकेट और न ही एक अंक:

(?<![|d)d+|d+(?!]|d)

अर्थात। (रूबी का उपयोग करना चाहिए?

>> rex = /(?<![|d)d+|d+(?!]|d)/
>> "&(*25asdasd*U(*&*()&(*3".match rex #=> #<MatchData "25">
>> "&(*[25asdasd*U(*&*()&(*3".match rex #=> #<MatchData "25">
>> "&(*25]asdasd*U(*&*()&(*3".match rex #=> #<MatchData "25">

परंतु

>> "&(*[25]asdasd*U(*&*()&(*3".match rex #=> #<MatchData "3">

---

जवाब के लिए 0 № 5

रेगेक्स केवल समाधान एक ओवरकिल होगा

बस उपयोग करें (^|D)(d+)($|D) और फिर पहले का चयन करें जो आपके मानदंडों से मेल खाता है।

सी # में, आप इसे इस तरह से कर सकते हैं

string output=Regex.Matches(input,@"(^|D)(d+)(D|$)")
.Cast<Match>()
.Where(x=>!(x.Value.StartsWith("[")&& x.Value.EndsWith("]")))
.First()
.Groups[2]
.Value;

---