मैं सहमत हूं कि XML और विशेष रूप से HTML को पार्स करने के लिए सही उपकरण एक नियमित पार्सर है और नियमित अभिव्यक्ति इंजन नहीं है। हालाँकि, जैसे अन्य लोगों ने बताया है, कभी-कभी एक रेग्जिक्स का उपयोग करना तेज, आसान होता है, और यदि आप डेटा प्रारूप जानते हैं तो काम पूरा हो जाता है।
Microsoft वास्तव में .NET फ्रेमवर्क में रेगुलर एक्सप्रेशंस के लिए बेस्ट प्रैक्टिस का एक सेक्शन है और विशेष रूप से इनपुट स्रोत पर विचार [आईएनजी] के बारे में बात करता है ।
नियमित एक्सप्रेशन की सीमाएँ हैं, लेकिन क्या आपने निम्नलिखित पर विचार किया है?
.NET फ्रेमवर्क अद्वितीय है जब यह नियमित अभिव्यक्तियों की बात करता है कि यह बैलेंसिंग ग्रुप परिभाषाओं का समर्थन करता है ।
इस कारण से, मेरा मानना है कि आप एक्सएमएल को रेग्युलर एक्सप्रेशंस का उपयोग करके पार्स कर सकते हैं। हालाँकि, ध्यान दें कि यह वैध XML होना चाहिए ( ब्राउज़र HTML के बहुत माफ करने वाले हैं और HTML के अंदर खराब XML सिंटैक्स की अनुमति देते हैं )। यह संभव है क्योंकि "बैलेंसिंग ग्रुप डेफिनिशन" नियमित अभिव्यक्ति इंजन को पीडीए के रूप में कार्य करने की अनुमति देगा।
ऊपर उद्धृत 1 लेख से उद्धरण:
.NET नियमित अभिव्यक्ति इंजन
जैसा कि ऊपर वर्णित ठीक से संतुलित निर्माण एक नियमित अभिव्यक्ति द्वारा वर्णित नहीं किया जा सकता है। हालाँकि, .NET नियमित अभिव्यक्ति इंजन कुछ निर्माण प्रदान करता है जो संतुलित निर्माण को मान्यता देता है।
(?<group>) - नाम समूह के साथ कैप्चर स्टैक पर कैप्चर किए गए परिणाम को धक्का देता है।(?<-group>) - कैप्चर स्टैक से नाम समूह के साथ शीर्ष सबसे अधिक कैप्चर करता है।(?(group)yes|no) - यदि हाँ नाम समूह के साथ एक समूह मौजूद है तो हाँ भाग से मेल खाता है अन्यथा भाग से मेल नहीं खाता है।
ये निर्माण आवश्यक रूप से स्टैक संचालन के सरल संस्करणों की अनुमति देकर एक प्रतिबंधित पीडीए का अनुकरण करने के लिए .NET नियमित अभिव्यक्ति की अनुमति देते हैं: पुश, पॉप और खाली। साधारण ऑपरेशन वेतन वृद्धि, वेतन वृद्धि के बराबर हैं और क्रमशः शून्य की तुलना करते हैं। यह .NET रेगुलर एक्सप्रेशन इंजन को संदर्भ-मुक्त भाषाओं के सबसेट को पहचानने की अनुमति देता है, विशेष रूप से उन लोगों के लिए जिन्हें केवल एक साधारण काउंटर की आवश्यकता होती है। यह बदले में गैर-पारंपरिक .NET नियमित अभिव्यक्तियों को व्यक्तिगत रूप से संतुलित निर्माणों को पहचानने की अनुमति देता है।
निम्नलिखित नियमित अभिव्यक्ति पर विचार करें:
(?=<ul\s+id="matchMe"\s+type="square"\s*>)
(?>
<!-- .*? --> |
<[^>]*/> |
(?<opentag><(?!/)[^>]*[^/]>) |
(?<-opentag></[^>]*[^/]>) |
[^<>]*
)*
(?(opentag)(?!))
झंडे का प्रयोग करें:
- इकलौती रेखा
- IgnorePatternWhitespace (आवश्यक नहीं है अगर आप regex को ढहते हैं और सभी व्हाट्सएप को हटा दें)
- इग्नोरकेस (आवश्यक नहीं)
नियमित अभिव्यक्ति की व्याख्या (इनलाइन)
(?=<ul\s+id="matchMe"\s+type="square"\s*>) # match start with <ul id="matchMe"...
(?> # atomic group / don't backtrack (faster)
<!-- .*? --> | # match xml / html comment
<[^>]*/> | # self closing tag
(?<opentag><(?!/)[^>]*[^/]>) | # push opening xml tag
(?<-opentag></[^>]*[^/]>) | # pop closing xml tag
[^<>]* # something between tags
)* # match as many xml tags as possible
(?(opentag)(?!)) # ensure no 'opentag' groups are on stack
आप इसे एक बेहतर .NET नियमित अभिव्यक्ति परीक्षक में आज़मा सकते हैं ।
मैंने इसका नमूना स्रोत इस्तेमाल किया:
<html>
<body>
<div>
<br />
<ul id="matchMe" type="square">
<li>stuff...</li>
<li>more stuff</li>
<li>
<div>
<span>still more</span>
<ul>
<li>Another >ul<, oh my!</li>
<li>...</li>
</ul>
</div>
</li>
</ul>
</div>
</body>
</html>
यह मैच मिला:
<ul id="matchMe" type="square">
<li>stuff...</li>
<li>more stuff</li>
<li>
<div>
<span>still more</span>
<ul>
<li>Another >ul<, oh my!</li>
<li>...</li>
</ul>
</div>
</li>
</ul>
हालांकि यह वास्तव में इस तरह से निकला:
<ul id="matchMe" type="square"> <li>stuff...</li> <li>more stuff</li> <li> <div> <span>still more</span> <ul> <li>Another >ul<, oh my!</li> <li>...</li> </ul> </div> </li> </ul>
अंत में, मुझे वास्तव में जेफ एटवुड का लेख पसंद आया: पार्सिंग एचटीएमएल द केथुलु वे । काफी मजेदार है, यह इस सवाल का जवाब बताता है कि वर्तमान में 4k से अधिक वोट हैं।