दिलचस्प पोस्ट
एक MySQL डाटाबेस में एक्सेल फ़ाइल कैसे आयात करें 'अगर' कथन बुरा क्यों माना जाता है? जावा में 2 डी मैट्रिक्स में सर्कल के रूप में डबल मान का प्रतिनिधित्व कैसे करें नेस्टेड पायथन डिक्शनरी, कम्प्रसेशन कुंजियां समतल करें जावास्क्रिप्ट में एक तारीख को बढ़ाना कैसे iPhone एसडीके का उपयोग कर एक GUID / यूआईआईडी बनाने के लिए क्वेरी परिणामों पर टी-एसक्यूएल लूप वेरिएबल्स के संबंध में ओवरराइडिंग के बारे में थोड़ा भ्रम एक UIViewController में एम्बेडेड UITableView में स्थिर कक्षों को नेत्रहीन कैसे बना और उपयोग करें कस्टम नियंत्रण में डिज़ाइन समर्थन को कैसे सक्षम करें? एक ब्रॉडकास्ट रिसीवर सक्षम और अक्षम करें आइकन पर Google क्रोम एक्सटेंशन नंबर क्रोम का उपयोग करना, यह कैसे पता चलता है कि कौन से तत्व एक घटना बाध्य है? कैसे प्रोग्रामिंग मेरे सी # आवेदन के बैंडविड्थ उपयोग को सीमित करने के लिए? HTML ईमेल – क्या colspan अनुमति है?

नियमित अभिव्यक्ति पैटर्न स्ट्रिंग में कहीं भी मेल नहीं खाता

मैं इस पैटर्न का उपयोग करके <input> प्रकार "छिपी" फ़ील्ड से मेल करने की कोशिश कर रहा हूं:

 /<input type="hidden" name="([^"]*?)" value="([^"]*?)" />/ 

यह नमूना फॉर्म डेटा है:

 <input type="hidden" name="SaveRequired" value="False" /><input type="hidden" name="__VIEWSTATE1" value="1H4sIAAtzrkX7QfL5VEGj6nGi+nP" /><input type="hidden" name="__VIEWSTATE2" value="0351118MK" /><input type="hidden" name="__VIEWSTATE3" value="ZVVV91yjY" /><input type="hidden" name="__VIEWSTATE0" value="3" /><input type="hidden" name="__VIEWSTATE" value="" /><input type="hidden" name="__VIEWSTATE" value="" /> 

लेकिन मुझे यकीन नहीं है कि type , name और value विशेषताओं को हमेशा उसी क्रम में दिखाई देगा। यदि type विशेषता पिछले है, तो मैच विफल हो जाएगा क्योंकि मेरे पैटर्न में यह शुरुआत में है।

सवाल:
मैं अपने पैटर्न को कैसे बदल सकता / सकती हूं, इसलिए यह <input> टैग के गुणों की स्थिति की परवाह किए बिना मेल करेगी?

पीएसः नियमित अभिव्यक्ति के परीक्षण के लिए जिस तरह से मैं एडोब एयर आधारित रेगएक्स डेस्कटॉप उपकरण का उपयोग कर रहा हूं।

Solutions Collecting From Web of "नियमित अभिव्यक्ति पैटर्न स्ट्रिंग में कहीं भी मेल नहीं खाता"

सभी उत्तरों के विपरीत, जो आप regex करने की कोशिश कर रहे हैं, एक बिल्कुल वैध समाधान है। इसका कारण यह है कि आप संतुलित टैग्स का मिलान करने की कोशिश नहीं कर रहे हैं – यह regex के साथ असंभव होगा! लेकिन आप केवल एक टैग में मेल खाते हैं, और यह बिल्कुल नियमित है।

यहाँ समस्या है, यद्यपि। आप इसे केवल एक regex के साथ नहीं कर सकते … आपको एक <input> टैग पर कब्जा करने के लिए एक मैच करने की ज़रूरत है, फिर उस पर आगे की प्रक्रिया करें। ध्यान दें कि यह केवल तभी काम करेगा यदि कोई भी विशेषता मानों में उनमें कोई वर्ण नहीं है, तो यह सही नहीं है, लेकिन समझदार इनपुट के लिए पर्याप्त होना चाहिए।

यहाँ कुछ पर्ल (छद्म) कोड है जो आपको दिखाता है कि मेरा क्या मतलब है:

 my $html = readLargeInputFile(); my @input_tags = $html =~ m/ ( <input # Starts with "<input" (?=[^>]*?type="hidden") # Use lookahead to make sure that type="hidden" [^>]+ # Grab the rest of the tag... \/> # ...except for the />, which is grabbed here )/xgm; # Now each member of @input_tags is something like <input type="hidden" name="SaveRequired" value="False" /> foreach my $input_tag (@input_tags) { my $hash_ref = {}; # Now extract each of the fields one at a time. ($hash_ref->{"name"}) = $input_tag =~ /name="([^"]*)"/; ($hash_ref->{"value"}) = $input_tag =~ /value="([^"]*)"/; # Put $hash_ref in a list or something, or otherwise process it } 

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

संपादित करें: हालांकि, मैं सहमत हूं कि सामान्य रूप से, एक HTML पार्टर का उपयोग करना संभवतः आसान और बेहतर है और आपको वास्तव में अपने कोड को फिर से डिज़ाइन करना चाहिए या अपने उद्देश्यों का पुन: परीक्षण करना चाहिए 🙂 लेकिन मुझे इस उत्तर को घुटने-झटका प्रतिक्रिया के रूप में पोस्ट करना पड़ा, जो कि एचटीएमएल के किसी भी उपसंचर को पार्स करना असंभव है: जब आप पूरे विनिर्देश पर विचार करते हैं तो HTML और एक्सएमएल दोनों अनियमित होते हैं, लेकिन एक टैग का विवरण विनम्रता से नियमित होता है , निश्चित रूप से पीसीआर की शक्ति के भीतर

ओह, हाँ, आप HTML पार्स करने के लिए रेगेक्स का उपयोग कर सकते हैं !

जिस कार्य के लिए आप प्रयास कर रहे हैं, regexes बिल्कुल ठीक हैं!

यह सच है कि ज्यादातर लोग नियमित अभिव्यक्तियों के साथ एचटीएमएल को पार्स करने में कठिनाई को कमजोर करते हैं और इसलिए ऐसा खराब तरीके से करते हैं।

लेकिन यह कम्प्यूटेशनल सिद्धांत से संबंधित कुछ मौलिक दोष नहीं है। उस मूर्खता को यहाँ बहुत कुछ बताया गया है, लेकिन आप उन पर विश्वास नहीं करते।

इसलिए जब यह निश्चित रूप से किया जा सकता है (यह पोस्टिंग इस निर्विवाद तथ्य का एक अस्तित्व प्रमाण के रूप में कार्य करता है), इसका मतलब यह नहीं होना चाहिए।

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

लेकिन मैं हूं। ☻


जनरल रेगेक्स-आधारित HTML पार्सिंग सॉल्यूशंस

सबसे पहले मैं दिखाएगा कि रीजेक्स के साथ मनमाना करने वाले एचटीएमएल को पार्स करना कितना आसान है I इस पोस्टिंग के अंत में पूरा कार्यक्रम है, लेकिन पार्सर का दिल यह है:

 for (;;) { given ($html) { last when (pos || 0) >= length; printf "\@%d=", (pos || 0); print "doctype " when / \G (?&doctype) $RX_SUBS /xgc; print "cdata " when / \G (?&cdata) $RX_SUBS /xgc; print "xml " when / \G (?&xml) $RX_SUBS /xgc; print "xhook " when / \G (?&xhook) $RX_SUBS /xgc; print "script " when / \G (?&script) $RX_SUBS /xgc; print "style " when / \G (?&style) $RX_SUBS /xgc; print "comment " when / \G (?&comment) $RX_SUBS /xgc; print "tag " when / \G (?&tag) $RX_SUBS /xgc; print "untag " when / \G (?&untag) $RX_SUBS /xgc; print "nasty " when / \G (?&nasty) $RX_SUBS /xgc; print "text " when / \G (?&nontag) $RX_SUBS /xgc; default { die "UNCLASSIFIED: " . substr($_, pos || 0, (length > 65) ? 65 : length); } } } 

देखना कितना आसान है?

लिखित रूप में, यह एचटीएमएल के प्रत्येक टुकड़े को पहचानता है और बताता है कि उस टुकड़े को कहाँ मिला। आप आसानी से इसे किसी भी प्रकार के किसी टुकड़े के साथ चाहते हैं, या इनसे अधिक विशेष प्रकार के लिए इसे आसानी से संशोधित कर सकते हैं।

मेरे पास कोई असफल टेस्ट केस नहीं है (बाएं :): मैंने 100,000 से अधिक HTML फ़ाइलों पर इस कोड को सफलतापूर्वक चलाया है – हर एक मैं जल्दी से और आसानी से मेरे हाथों को प्राप्त कर सकता था उनसे परे, मैंने इसे विशेष रूप से भोले पार्सर को तोड़ने के लिए बनाई गई फ़ाइलों पर चलाया है।

यह एक भोला पार्सर नहीं है

ओह, मुझे यकीन है कि यह सही नहीं है, लेकिन मैंने इसे अभी तक तोड़ने में कामयाब नहीं किया है। मुझे लगता है कि अगर कुछ भी होता है, तो कार्यक्रम के स्पष्ट संरचना के कारण फिक्स फिट होना आसान होगा। यहां तक ​​कि regex- भारी कार्यक्रमों stucture होना चाहिए

अब जब कि रास्ते से बाहर हो, मुझे ओपी के सवाल को संबोधित करते हैं।

रेगेक्स का इस्तेमाल करते हुए ओपी के कार्य को सुलझाने का डेमो

मैं नीचे दिए गए छोटे html_input_rx प्रोग्राम को निम्न आउटपुट का उत्पादन करता है, ताकि आप देख सकें कि regexes के साथ HTML पार्स करने से आप जो करना चाहते हैं, उसके लिए ठीक काम करता है:

 % html_input_rx Amazon.com-_Online_Shopping_for_Electronics,_Apparel,_Computers,_Books,_DVDs_\&_more.htm input tag #1 at character 9955: class => "searchSelect" id => "twotabsearchtextbox" name => "field-keywords" size => "50" style => "width:100%; background-color: #FFF;" title => "Search for" type => "text" value => "" input tag #2 at character 10335: alt => "Go" src => "http://img.hiwab.com/html/transparent-pixel._V192234675_.gif" type => "image" 

इनपुट टैग पार्स करें, कोई बुरा इनपुट नहीं देखें

यहाँ कार्यक्रम के लिए स्रोत है जो उपरोक्त उत्पादन का उत्पादन करता है।

 #!/usr/bin/env perl # # html_input_rx - pull out all <input> tags from (X)HTML src # via simple regex processing # # Tom Christiansen <tchrist@perl.com> # Sat Nov 20 10:17:31 MST 2010 # ################################################################ use 5.012; use strict; use autodie; use warnings FATAL => "all"; use subs qw{ see_no_evil parse_input_tags input descape dequote load_patterns }; use open ":std", IN => ":bytes", OUT => ":utf8"; use Encode qw< encode decode >; ########################################################### parse_input_tags see_no_evil input ########################################################### until eof(); sub parse_input_tags { my $_ = shift(); our($Input_Tag_Rx, $Pull_Attr_Rx); my $count = 0; while (/$Input_Tag_Rx/pig) { my $input_tag = $+{TAG}; my $place = pos() - length ${^MATCH}; printf "input tag #%d at character %d:\n", ++$count, $place; my %attr = (); while ($input_tag =~ /$Pull_Attr_Rx/g) { my ($name, $value) = @+{ qw< NAME VALUE > }; $value = dequote($value); if (exists $attr{$name}) { printf "Discarding dup attr value '%s' on %s attr\n", $attr{$name} // "<undef>", $name; } $attr{$name} = $value; } for my $name (sort keys %attr) { printf " %10s => ", $name; my $value = descape $attr{$name}; my @Q; given ($value) { @Q = qw[ " " ] when !/'/ && !/"/; @Q = qw[ " " ] when /'/ && !/"/; @Q = qw[ ' ' ] when !/'/ && /"/; @Q = qw[ q( ) ] when /'/ && /"/; default { die "NOTREACHED" } } say $Q[0], $value, $Q[1]; } print "\n"; } } sub dequote { my $_ = $_[0]; s{ (?<quote> ["'] ) (?<BODY> (?s: (?! \k<quote> ) . ) * ) \k<quote> }{$+{BODY}}six; return $_; } sub descape { my $string = $_[0]; for my $_ ($string) { s{ (?<! % ) % ( \p{Hex_Digit} {2} ) }{ chr hex $1; }gsex; s{ & \043 ( [0-9]+ ) (?: ; | (?= [^0-9] ) ) }{ chr $1; }gsex; s{ & \043 x ( \p{ASCII_HexDigit} + ) (?: ; | (?= \P{ASCII_HexDigit} ) ) }{ chr hex $1; }gsex; } return $string; } sub input { our ($RX_SUBS, $Meta_Tag_Rx); my $_ = do { local $/; <> }; my $encoding = "iso-8859-1"; # web default; wish we had the HTTP headers :( while (/$Meta_Tag_Rx/gi) { my $meta = $+{META}; next unless $meta =~ m{ $RX_SUBS (?= http-equiv ) (?&name) (?&equals) (?= (?&quote)? content-type ) (?&value) }six; next unless $meta =~ m{ $RX_SUBS (?= content ) (?&name) (?&equals) (?<CONTENT> (?&value) ) }six; next unless $+{CONTENT} =~ m{ $RX_SUBS (?= charset ) (?&name) (?&equals) (?<CHARSET> (?&value) ) }six; if (lc $encoding ne lc $+{CHARSET}) { say "[RESETTING ENCODING $encoding => $+{CHARSET}]"; $encoding = $+{CHARSET}; } } return decode($encoding, $_); } sub see_no_evil { my $_ = shift(); s{ <! DOCTYPE .*? > }{}sx; s{ <! \[ CDATA \[ .*? \]\] > }{}gsx; s{ <script> .*? </script> }{}gsix; s{ <!-- .*? --> }{}gsx; return $_; } sub load_patterns { our $RX_SUBS = qr{ (?(DEFINE) (?<nv_pair> (?&name) (?&equals) (?&value) ) (?<name> \b (?= \pL ) [\w\-] + (?<= \pL ) \b ) (?<equals> (?&might_white) = (?&might_white) ) (?<value> (?&quoted_value) | (?&unquoted_value) ) (?<unwhite_chunk> (?: (?! > ) \S ) + ) (?<unquoted_value> [\w\-] * ) (?<might_white> \s * ) (?<quoted_value> (?<quote> ["'] ) (?: (?! \k<quote> ) . ) * \k<quote> ) (?<start_tag> < (?&might_white) ) (?<end_tag> (?&might_white) (?: (?&html_end_tag) | (?&xhtml_end_tag) ) ) (?<html_end_tag> > ) (?<xhtml_end_tag> / > ) ) }six; our $Meta_Tag_Rx = qr{ $RX_SUBS (?<META> (?&start_tag) meta \b (?: (?&might_white) (?&nv_pair) ) + (?&end_tag) ) }six; our $Pull_Attr_Rx = qr{ $RX_SUBS (?<NAME> (?&name) ) (?&equals) (?<VALUE> (?&value) ) }six; our $Input_Tag_Rx = qr{ $RX_SUBS (?<TAG> (?&input_tag) ) (?(DEFINE) (?<input_tag> (?&start_tag) input (?&might_white) (?&attributes) (?&might_white) (?&end_tag) ) (?<attributes> (?: (?&might_white) (?&one_attribute) ) * ) (?<one_attribute> \b (?&legal_attribute) (?&might_white) = (?&might_white) (?: (?&quoted_value) | (?&unquoted_value) ) ) (?<legal_attribute> (?: (?&optional_attribute) | (?&standard_attribute) | (?&event_attribute) # for LEGAL parse only, comment out next line | (?&illegal_attribute) ) ) (?<illegal_attribute> (?&name) ) (?<required_attribute> (?#no required attributes) ) (?<optional_attribute> (?&permitted_attribute) | (?&deprecated_attribute) ) # NB: The white space in string literals # below DOES NOT COUNT! It's just # there for legibility. (?<permitted_attribute> accept | alt | bottom | check box | checked | disabled | file | hidden | image | max length | middle | name | password | radio | read only | reset | right | size | src | submit | text | top | type | value ) (?<deprecated_attribute> align ) (?<standard_attribute> access key | class | dir | ltr | id | lang | style | tab index | title | xml:lang ) (?<event_attribute> on blur | on change | on click | on dbl click | on focus | on mouse down | on mouse move | on mouse out | on mouse over | on mouse up | on key down | on key press | on key up | on select ) ) }six; } UNITCHECK { load_patterns(); } END { close(STDOUT) || die "can't close stdout: $!"; } 

तुम वहाँ जाओ! इसको कुछ नहीं! 🙂

केवल आप ही फैसला कर सकते हैं कि क्या regexes के साथ आपके कौशल किसी विशेष पार्सिंग कार्य पर निर्भर है। हर कोई कौशल का स्तर अलग है, और हर नया काम अलग है। जिन नौकरियों में आपके पास एक अच्छी तरह से परिभाषित इनपुट सेट है, regexes स्पष्ट रूप से सही विकल्प हैं, क्योंकि आपके पास एचटीएमएल के एक सीमित सबसेट के साथ निपटने के लिए कुछ एक साथ रखना मुश्किल है। यहां तक ​​कि regex शुरुआती regexes के साथ उन नौकरियों को संभालना चाहिए। कुछ और अधिक है overkill

हालांकि , एक बार एचटीएमएल कम हो जाने पर, एक बार जब आप चीजों की अधिक विविधता या अधिक जटिल निर्भरता से मेल खाते हैं, तो आप अंततः एक बिंदु तक पहुंच सकते हैं आपको किसी ऐसे समाधान को प्रभावित करने के लिए कड़ी मेहनत करनी पड़ती है जो एक पार्सिंग क्लास का उपयोग करना पड़ता है। जहां वह ब्रेक-पॉइंट प्वाइंट रीजेंक्स के साथ अपने खुद के आराम स्तर पर फिर से निर्भर करता है।

तो मुझे क्या करना चाहिए?

मैं आपको यह बताने वाला नहीं हूँ कि आपको क्या करना चाहिए या आप क्या नहीं कर सकते । मुझे लगता है कि गलत है मैं बस आपको संभावनाओं के साथ पेश करना चाहता हूं, अपनी आंखों को थोड़ा सा खोलें। आप यह चुन लेते हैं कि आप क्या करना चाहते हैं और आप इसे कैसे करना चाहते हैं। कोई निरपेक्षता नहीं है – और कोई भी आपकी खुद की स्थिति और साथ ही आप खुद को नहीं जानता। अगर कुछ ऐसा लगता है कि यह बहुत काम है, ठीक है, शायद यह है प्रोग्रामिंग मज़ेदार होना चाहिए, आप जानते हैं अगर ऐसा नहीं है, तो आप इसे गलत कर रहे हैं।

किसी भी संख्या में वैध तरीके से अपने html_input_rx प्रोग्राम को देख सकते हैं html_input_rx ऐसा एक ऐसा है कि आप नियमित अभिव्यक्ति के साथ HTML को पार्स कर सकते हैं । लेकिन एक और यह है कि यह बहुत ज्यादा है, बहुत ज्यादा है, जितना कठिन लगता है, उतना ही कभी भी ऐसा लगता है कि यह है। यह आसानी से इस निष्कर्ष पर पहुंचा सकता है कि मेरा कार्यक्रम एक ऐसा नियम है जो आपको नहीं करना चाहिए, क्योंकि यह वाकई बहुत कठिन है।

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

छोटे HTML पार्सिंग समस्याओं के लिए रेगेक्सस इष्टतम, बड़े लोगों के लिए असामान्य

यहां तक ​​कि अगर मेरे कार्यक्रम को स्पष्ट रूप में लिया गया है कि आपको सामान्य HTML को पार्स करने के लिए regexes का उपयोग क्यों नहीं करना चाहिए – जो ठीक है, क्योंकि मैं थोड़े होने के लिए इसका मतलब था – यह अभी भी एक आंख खोलने वाला होना चाहिए ताकि अधिक लोगों को बहुत आम हो और अपठनीय, असंरचित, और unmaintainable पैटर्न लिखने की बुरा, गंदा आदत

पैटर्नों को बदसूरत नहीं होना चाहिए, और उन्हें कठोर होना ज़रूरी नहीं है यदि आप बदसूरत पैटर्न बनाते हैं, तो यह आपके प्रतिबिंब है, न कि उन्हें।

भयानक उत्तम रेगेक्स भाषा

मुझे यह बताने के लिए कहा गया है कि आपकी समस्या का मेरा प्रोफ़ेसर समाधान पर्ल में लिखा गया है। क्या आप आश्चर्यचकित हैं? क्या आपने ध्यान नहीं दिया? क्या यह रहस्योद्घाटन एक बकवास है?

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

यह सच है कि पर्ल के रूप में regexes की बात करते समय सभी अन्य उपकरण और प्रोग्रामिंग भाषाएं सुविधाजनक, अभिव्यंजक और शक्तिशाली नहीं हैं वहाँ एक बड़ा स्पेक्ट्रम है, कुछ के साथ दूसरों की तुलना में अधिक उपयुक्त है। सामान्य तौर पर, लाइब्रेरी के बजाए कोर भाषा के एक भाग के रूप में रेगेक्स को प्रदर्शित की जाने वाली भाषाओं के साथ काम करना आसान होता है। मैंने regexes के साथ कुछ भी नहीं किया है कि आप ऐसा नहीं कर सकते, कहते हैं, पीसीई, हालांकि आप सी प्रोग्राम का उपयोग करते हुए अलग ढंग से संरचना करेंगे।

आखिरकार अन्य भाषाओं को पकड़ लिया जाएगा जहां पर्ल अब regexes के संदर्भ में है। मैं यह कह रहा हूं क्योंकि पर्ल की शुरुआत के बाद, किसी और को पर्ल के रेगेक्स की तरह कुछ नहीं था। आपको जो कुछ कहना पसंद है, लेकिन यह वह जगह है जहां पर्ल स्पष्ट रूप से जीता है: सभी ने पर्ल के रेगेक्स की नकल की, हालांकि उनके विकास के विभिन्न चरणों में। पर्ल ने लगभग (लगभग बिल्कुल नहीं, लेकिन लगभग) जो कुछ भी आप आज के आधुनिक पैटर्नों पर भरोसा करने के लिए आए हैं, कोई भी उपकरण या भाषा जिसका आप उपयोग नहीं करते हैं। तो अंततः दूसरों को पकड़ना होगा

लेकिन वे केवल उस पल को पकड़ पाएंगे, जहां पर्ल कुछ समय पहले ही था, जैसे ही अब है। सब कुछ अग्रिम Regexes में अगर कुछ नहीं, जहां पर्ल होता है, दूसरों का पालन करें जहां पर्ल एक बार हो सकता है और आखिरकार जहां पर्ल अब तक कैच हो जाता है? मुझे पता नहीं है, लेकिन मुझे पता है हम भी चले गए होंगे शायद हम पैटर्न के क्राफ्टिंग की पर्ल की शैली के करीब होंगे।

यदि आप उस तरह की चीज़ पसंद करते हैं लेकिन इसे पर्ल में उपयोग करना चाहते हैं, तो आप दमैयन कॉनवे के अद्भुत रेगेक्स :: ग्रामर्स मॉड्यूल में दिलचस्पी ले सकते हैं। यह पूरी तरह से भयानक है, और मेरे कार्यक्रम में मैंने जो कुछ किया है, वह उतना ही आदिम लगता है क्योंकि मेरा ऐसा पैटर्न बनाता है कि लोगों को बिना किसी रिक्त स्थान या वर्णानुक्रमिक आइडेंटिफायर के मिलते हैं इसकी जांच – पड़ताल करें!


सरल एचटीएमएल चंकर

यहां पार्सर का पूरा स्रोत यह है कि मैंने इस पोस्टिंग की शुरुआत से केंद्रस्थानी दिखाया।

मैं सुझाव नहीं दे रहा हूं कि आपको इसे कड़ाई से परीक्षण किए गए पार्सिंग क्लास पर इस्तेमाल करना चाहिए। लेकिन मैं लोगों से थक गया हूं कि कोई भी एचटीएमएल के साथ regexes पार्स नहीं कर सकता क्योंकि वे नहीं कर सकते। आप स्पष्ट रूप से कर सकते हैं, और यह कार्यक्रम इस तर्क के सबूत है।

ज़रूर, यह आसान नहीं है, लेकिन यह संभव है!

और ऐसा करने का प्रयास समय का एक भयानक अपशिष्ट है, क्योंकि अच्छे पार्सिंग वर्ग मौजूद हैं जो आपको इस कार्य के लिए उपयोग करना चाहिएमनमानी एचटीएमएल पार्स करने की कोशिश करने वाले लोगों को सही जवाब नहीं है कि यह असंभव है यह सहज और कपटी उत्तर है सही और ईमानदार उत्तर यह है कि उन्हें इसका प्रयास नहीं करना चाहिए क्योंकि यह खरोंच से बाहर निकालने में बहुत अधिक परेशान है; उन्हें अपनी पीठ को तोड़ने से नहीं रोकना चाहिए, जो एक पहिया को फिर से बनाने का प्रयास करता है जो पूरी तरह से अच्छी तरह से काम करता है।

दूसरी तरफ, एचटीएमएल जो एक अनुमान वाले सबसेट के भीतर आता है, वह रेगेक्सस के साथ पार्स करने के लिए अल्ट्रा-आसान है। यह कोई आश्चर्य नहीं कि लोग इसका इस्तेमाल करने की कोशिश करते हैं, क्योंकि छोटी समस्याएं, खिलौना समस्याएं शायद कुछ भी आसान नहीं हो सकतीं। यही कारण है कि यह दो कार्यों में विशिष्ट होना ज़रूरी है- विशिष्ट बनाम जेनेरिक – क्योंकि ये जरूरी नहीं कि उसी दृष्टिकोण की मांग करें

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

यहाँ मेरा एचटीएमएल लेक्सर है यह मान्य पर्स करने की कोशिश नहीं करता; यह सिर्फ शाब्दिक तत्वों को पहचानता है आप एचटीएमएल पार्सर के मुकाबले एक एचटीएमएल चंकर के बारे में सोच सकते हैं। यह टूटी हुई HTML का बहुत क्षमा नहीं है, हालांकि यह उस दिशा में कुछ बहुत ही छोटे भत्ते करता है।

यहां तक ​​कि अगर आप खुद को पूर्ण HTML का विश्लेषण नहीं करते हैं (और आपको क्यों करना चाहिए? यह एक हल समस्या है!), इस कार्यक्रम में बहुत सारे शांत regex बिट्स हैं जो मेरा मानना ​​है कि बहुत से लोग बहुत कुछ सीख सकते हैं। का आनंद लें!

 #!/usr/bin/env perl # # chunk_HTML - a regex-based HTML chunker # # Tom Christiansen <tchrist@perl.com # Sun Nov 21 19:16:02 MST 2010 ######################################## use 5.012; use strict; use autodie; use warnings qw< FATAL all >; use open qw< IN :bytes OUT :utf8 :std >; MAIN: { $| = 1; lex_html(my $page = slurpy()); exit(); } ######################################################################## sub lex_html { our $RX_SUBS; ############### my $html = shift(); # Am I... # for (;;) { # forgiven? :)# given ($html) { ############### last when (pos || 0) >= length; printf "\@%d=", (pos || 0); print "doctype " when / \G (?&doctype) $RX_SUBS /xgc; print "cdata " when / \G (?&cdata) $RX_SUBS /xgc; print "xml " when / \G (?&xml) $RX_SUBS /xgc; print "xhook " when / \G (?&xhook) $RX_SUBS /xgc; print "script " when / \G (?&script) $RX_SUBS /xgc; print "style " when / \G (?&style) $RX_SUBS /xgc; print "comment " when / \G (?&comment) $RX_SUBS /xgc; print "tag " when / \G (?&tag) $RX_SUBS /xgc; print "untag " when / \G (?&untag) $RX_SUBS /xgc; print "nasty " when / \G (?&nasty) $RX_SUBS /xgc; print "text " when / \G (?&nontag) $RX_SUBS /xgc; default { die "UNCLASSIFIED: " . substr($_, pos || 0, (length > 65) ? 65 : length); } } } say "."; } ##################### # Return correctly decoded contents of next complete # file slurped in from the <ARGV> stream. # sub slurpy { our ($RX_SUBS, $Meta_Tag_Rx); my $_ = do { local $/; <ARGV> }; # read all input return unless length; use Encode qw< decode >; my $bom = ""; given ($_) { $bom = "UTF-32LE" when / ^ \xFf \xFe \0 \0 /x; # LE $bom = "UTF-32BE" when / ^ \0 \0 \xFe \xFf /x; # BE $bom = "UTF-16LE" when / ^ \xFf \xFe /x; # le $bom = "UTF-16BE" when / ^ \xFe \xFf /x; # be $bom = "UTF-8" when / ^ \xEF \xBB \xBF /x; # st00pid } if ($bom) { say "[BOM $bom]"; s/^...// if $bom eq "UTF-8"; # st00pid # Must use UTF-(16|32) w/o -[BL]E to strip BOM. $bom =~ s/-[LB]E//; return decode($bom, $_); # if BOM found, don't fall through to look # for embedded encoding spec } # Latin1 is web default if not otherwise specified. # No way to do this correctly if it was overridden # in the HTTP header, since we assume stream contains # HTML only, not also the HTTP header. my $encoding = "iso-8859-1"; while (/ (?&xml) $RX_SUBS /pgx) { my $xml = ${^MATCH}; next unless $xml =~ m{ $RX_SUBS (?= encoding ) (?&name) (?&equals) (?&quote) ? (?<ENCODING> (?&value) ) }sx; if (lc $encoding ne lc $+{ENCODING}) { say "[XML ENCODING $encoding => $+{ENCODING}]"; $encoding = $+{ENCODING}; } } while (/$Meta_Tag_Rx/gi) { my $meta = $+{META}; next unless $meta =~ m{ $RX_SUBS (?= http-equiv ) (?&name) (?&equals) (?= (?&quote)? content-type ) (?&value) }six; next unless $meta =~ m{ $RX_SUBS (?= content ) (?&name) (?&equals) (?<CONTENT> (?&value) ) }six; next unless $+{CONTENT} =~ m{ $RX_SUBS (?= charset ) (?&name) (?&equals) (?<CHARSET> (?&value) ) }six; if (lc $encoding ne lc $+{CHARSET}) { say "[HTTP-EQUIV ENCODING $encoding => $+{CHARSET}]"; $encoding = $+{CHARSET}; } } return decode($encoding, $_); } ######################################################################## # Make sure to this function is called # as soon as source unit has been compiled. UNITCHECK { load_rxsubs() } # useful regex subroutines for HTML parsing sub load_rxsubs { our $RX_SUBS = qr{ (?(DEFINE) (?<WS> \s * ) (?<any_nv_pair> (?&name) (?&equals) (?&value) ) (?<name> \b (?= \pL ) [\w:\-] + \b ) (?<equals> (?&WS) = (?&WS) ) (?<value> (?&quoted_value) | (?&unquoted_value) ) (?<unwhite_chunk> (?: (?! > ) \S ) + ) (?<unquoted_value> [\w:\-] * ) (?<any_quote> ["'] ) (?<quoted_value> (?<quote> (?&any_quote) ) (?: (?! \k<quote> ) . ) * \k<quote> ) (?<start_tag> < (?&WS) ) (?<html_end_tag> > ) (?<xhtml_end_tag> / > ) (?<end_tag> (?&WS) (?: (?&html_end_tag) | (?&xhtml_end_tag) ) ) (?<tag> (?&start_tag) (?&name) (?: (?&WS) (?&any_nv_pair) ) * (?&end_tag) ) (?<untag> </ (?&name) > ) # starts like a tag, but has screwed up quotes inside it (?<nasty> (?&start_tag) (?&name) .*? (?&end_tag) ) (?<nontag> [^<] + ) (?<string> (?&quoted_value) ) (?<word> (?&name) ) (?<doctype> <!DOCTYPE # please don't feed me nonHTML ### (?&WS) HTML [^>]* > ) (?<cdata> <!\[CDATA\[ .*? \]\] > ) (?<script> (?= <script ) (?&tag) .*? </script> ) (?<style> (?= <style ) (?&tag) .*? </style> ) (?<comment> <!-- .*? --> ) (?<xml> < \? xml (?: (?&WS) (?&any_nv_pair) ) * (?&WS) \? > ) (?<xhook> < \? .*? \? > ) ) }six; our $Meta_Tag_Rx = qr{ $RX_SUBS (?<META> (?&start_tag) meta \b (?: (?&WS) (?&any_nv_pair) ) + (?&end_tag) ) }six; } # nobody *ever* remembers to do this! END { close STDOUT } 
  1. आप टीच्रिस्ट जैसी उपन्यास लिख सकते हैं
  2. आप एक DOM लाइब्रेरी का उपयोग कर, एचटीएमएल लोड कर सकते हैं और एक्सपेथ का इस्तेमाल कर सकते हैं और बस //input[@type="hidden"] । या अगर आप xpath का उपयोग नहीं करना चाहते हैं, तो बस सभी निविष्टियाँ और फ़िल्टर प्राप्त करें, जो कि getAttribute साथ छिपे हुए हैं

मुझे पसंद है # 2

 <?php $d = new DOMDocument(); $d->loadHTML( ' <p>fsdjl</p> <form><div>fdsjl</div></form> <input type="hidden" name="blah" value="hide yo kids"> <input type="text" name="blah" value="hide yo kids"> <input type="hidden" name="blah" value="hide yo wife"> '); $x = new DOMXpath($d); $inputs = $x->evaluate('//input[@type="hidden"]'); foreach ( $inputs as $input ) { echo $input->getAttribute('value'), '<br>'; } 

परिणाम:

 hide yo kids<br>hide yo wife<br> 

टॉम क्रिस्टियनन के लिक्सर समाधान की भावना में, यहां रॉबर्ट कैमरन के 1 99 8 के लेख को याद करते हुए लिंक है, रेक्स: एक्सएमएल शेलो पार्सिंग विद रेगुलर एक्सप्रेशंस।

http://www.cs.sfu.ca/~cameron/REX.html

सार

एक्सएमएल का वाक्यविन्यास काफी सरल है कि एक XML दस्तावेज़ को एक नियमित अभिव्यक्ति का उपयोग करके इसके मार्कअप और टेक्स्ट आइटम की सूची में पार्स करना संभव है। एक XML दस्तावेज़ का एक उथल पार्स बहुत हल्के एक्सएमएल प्रसंस्करण औजार के निर्माण के लिए बहुत उपयोगी हो सकता है। हालांकि, जटिल रेगुलर एक्सप्रेशंस का निर्माण करना मुश्किल हो सकता है और पढ़ने में और भी मुश्किल हो सकता है नियमित अभिव्यक्ति के लिए साक्षरता प्रोग्रामिंग के एक फार्म का उपयोग करते हुए, यह पत्र XML उथले पार्सिंग अभिव्यक्ति का एक समूह है जिसका उपयोग सरल, सही, कुशल, मजबूत और भाषा-स्वतंत्र XML उथले पार्सिंग के लिए किया जा सकता है। पर्ल, जावास्क्रिप्ट और लेक्स / फ्लेक्स में प्रत्येक से कम 50 लाइनों के पूर्ण उथले पार्सर लागूकरण भी दिए जाते हैं।

अगर आप नियमित अभिव्यक्तियों के बारे में पढ़ना पसंद करते हैं, तो कैमरून का पेपर आकर्षक है उनका लेखन संक्षिप्त, पूर्ण, और बहुत विस्तृत है। वह बस आपको नहीं दिखा रहा है कि रीएक्स रेग्युलर एक्सप्रेशन का निर्माण कैसे किया जाए, लेकिन छोटे हिस्सों से किसी भी जटिल रेगेक्स को बनाने के लिए एक दृष्टिकोण भी है।

मैं आरईएक्स के रेगुलर एक्सप्रेशन का इस्तेमाल 10 साल के लिए कर रहा हूं और शुरुआती पोस्टर के बारे में पूछे जाने वाले समस्या को हल करने के लिए (मैं यह विशेष टैग कैसे मेल करता हूं, लेकिन कुछ अन्य बहुत ही समान टैग नहीं?)। मैंने पूरी तरह विश्वसनीय होने के लिए विकसित किए गए रेगेक्स को पाया है

REX विशेष रूप से उपयोगी होता है जब आप किसी दस्तावेज़ के लेक्सिकल विवरण पर ध्यान केंद्रित कर रहे हैं – उदाहरण के लिए, जब एक तरह का पाठ दस्तावेज़ (जैसे, सादा पाठ, XML, एसजीएमएल, एचटीएमएल) दूसरे में बदलते हैं, जहां दस्तावेज़ मान्य नहीं हो सकता है, सबसे अधिक परिवर्तन के लिए अच्छी तरह से गठित, या पारस्परिक भी। यह आपको दस्तावेज़ के बाकी हिस्सों को परेशान किए बिना किसी दस्तावेज़ के भीतर कहीं भी मार्कअप के द्वीपों को लक्षित करने देता है।

हालांकि मुझे इन सभी उत्तरों की सामग्री पसंद है, लेकिन वे वास्तव में सीधे या सही तरीके से सवाल का जवाब नहीं देते थे यहां तक ​​कि प्लैटिनम का उत्तर अत्यधिक जटिल था, और कम कुशल भी था। इसलिए मुझे यह लगाया गया था।

मैं Regex का एक बड़ा प्रस्तावक हूँ, जब सही तरीके से इस्तेमाल किया गया लेकिन कलंक (और निष्पादन) के कारण, मैं हमेशा कहता हूं कि अच्छी तरह से बनाई गई XML या HTML को XML पार्सर का उपयोग करना चाहिए। और यहां तक ​​कि बेहतर प्रदर्शन स्ट्रिंग-पार्सिंग होगा, यद्यपि पठनीयता के बीच एक पंक्ति होती है, अगर वह बिना आउट-आउट हो हालांकि, यह सवाल नहीं है प्रश्न यह है कि छिपे हुए प्रकार के इनपुट टैग से मिलान कैसे किया जाता है। उत्तर है:

 <input[^>]*type="hidden"[^>]*> 

आपके स्वाद पर निर्भर करते हुए, केवल एक regex विकल्प जिसे आप में शामिल करना होगा, वह अनदेखी विकल्प है

you can try this :

 <[A-Za-z ="/_0-9+]*> 

and for closer result you can try this :

 <[ ]*input[ ]+type="hidden"[ ]*name=[A-Za-z ="_0-9+]*[ ]*[/]*> 

you can test your regex pattern here http://regexpal.com/

these pattens are good for this:

 <input type="hidden" name="SaveRequired" value="False" /><input type="hidden" name="__VIEWSTATE1" value="1H4sIAAtzrkX7QfL5VEGj6nGi+nP" /><input type="hidden" name="__VIEWSTATE2" value="0351118MK" /><input type="hidden" name="__VIEWSTATE3" value="ZVVV91yjY" /> 

and for random order of type , name and value u can use this :

 <[ ]*input[ ]*[A-Za-z ="_0-9+/]*> 

या

 <[ ]*input[ ]*[A-Za-z ="_0-9+/]*[ ]*[/]> 

on this :

 <input name="SaveRequired" type="hidden" value="False" /><input type="hidden" name="__VIEWSTATE1" value="1H4sIAAtzrkX7QfL5VEGj6nGi+nP" /><input type="hidden" name="__VIEWSTATE2" value="0351118MK" /><input name="__VIEWSTATE3" type="hidden" value="ZVVV91yjY" /> 

`

by the way i think you want something like this :

 <[ ]*input(([ ]*type="hidden"[ ]*name=[A-Za-z0-9_+"]*[ ]*value=[A-Za-z0-9_+"]*[ ]*)+)[ ]*/>|<[ ]*input(([ ]*type="hidden"[ ]*value=[A-Za-z0-9_+"]*[ ]*name=[A-Za-z0-9_+"]*[ ]*)+)[ ]*/>|<[ ]*input(([ ]*name=[A-Za-z0-9_+"]*[ ]*type="hidden"[ ]*value=[A-Za-z0-9_+"]*[ ]*)+)[ ]*/>|<[ ]*input(([ ]*value=[A-Za-z0-9_+"]*[ ]*type="hidden"[ ]*name=[A-Za-z0-9_+"]*[ ]*)+)[ ]*/>|<[ ]*input(([ ]*name=[A-Za-z0-9_+"]*[ ]*value=[A-Za-z0-9_+"]*[ ]*type="hidden"[ ]*)+)[ ]*/>|<[ ]*input(([ ]*value=[A-Za-z0-9_+"]*[ ]*name=[A-Za-z0-9_+"]*[ ]*type="hidden"[ ]*)+)[ ]*/> 

its not good but it works in any way.

test it in : http://regexpal.com/

I would like to use **DOMDocument** to extract the html code.

 $dom = new DOMDocument(); $dom ->loadHTML($input); $x = new DOMXpath($dom ); $results = $x->evaluate('//input[@type="hidden"]'); foreach ( $results as $item) { print_r( $item->getAttribute('value') ); } 

BTW, you can test it in here – regex101.com. It shows the result at real time. Some rules about Regexp: http://www.eclipse.org/tptp/home/downloads/installguide/gla_42/ref/rregexp.html Reader .

suppose your html content is stored in string html then in order to get every input that contain type hidden you can use regular expression

 var regex = /(<input.*?type\s?=\s?["']hidden["'].*?>)/g; html.match(regex); 

the above regex find <input followed by any number of characters until it gets type="hidden" or type='hidden' followed by any number of characters till it gets >

/g tell regular expression to find every substring that matches to the given pattern.