kzen.dev
Mai mult
Question

Ce să fac expresie Regulată model nu't se potrivesc oriunde în șir?

Am încercat pentru a se potrivi <input> tip "ascunse" câmpuri folosind acest model:

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

Acest exemplu de formular de date:

<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="" />

Dar eu nu sunt sigur că "tip", "nume", și "valoare" atribute va apărea întotdeauna în aceeași ordine. Dacă atributul "type" vine trecută, meciul va eșua, deoarece în modelul meu e la început.

Întrebare: Cum pot schimba modelul astfel încât se va potrivi indiferent de pozițiile de atribute în `<input> tag?

P. S.: apropo eu sunt, folosind Adobe Air bazat RegEx Instrument Desktop pentru testarea expresii regulate.

Programare
regex
html
parsing

Oh, Da, Puteți Utilizarea Regexes să Parse HTML!

Pentru activitatea pe care o încearcă, regexes sunt perfectly bine! Este adevărat că cei mai mulți oameni subestima dificultatea de parsarea HTML cu expresii regulate și, prin urmare, nu atât de prost. Dar acest lucru nu este un defect fundamental legată de calcul teoria. Ce imbecilitate este dat o mulțime în jurul valorii de aici, dar nu-i crezi. Deci, în timp ce cu siguranță poate fi făcut (aceasta postare servește ca o existență dovadă a acestui fapt incontestabil), asta nu înseamnă că should fi. Tu trebuie să decidă pentru tine, dacă sunteți de până la sarcina de a scrie ceea ce echivalează cu o dedicate, speciale HTML parser de regexes. Majoritatea oamenilor nu sunt. Dar n am. ☻

General Regex Bazate pe HTML Parsing Soluții

Mai întâi vă voi arăta cât de ușor este de a analiza arbitrare HTML cu regexes. Programul complet este la sfârșitul acestui anunt, dar inima parser este: 

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);
    }
  }
}

Vezi cât de ușor care este de a citi? După cum este scris, se identifică fiecare bucată de HTML si spune unde s-a constatat că bucata. Ai putea modifica cu ușurință de a face orice altceva vrei cu orice tip de piesa, sau pentru mai multe tipuri particulare decât acestea. Nu am nici o lipsa de cazuri de testare (stânga :): am rulat cu succes acest cod pe mai mult de 100.000 de fișiere HTML — fiecare am putea obține rapid și ușor pe mâinile mele. Dincolo de astea, am, de asemenea, rula pe fișiere construit special pentru a rupe naïve interpretoare. Acest lucru este nu o naïve parser. Oh, eu sunt sigur că nu e perfectă, dar n-am reușit să-l rupă încă. M-am gândit că, chiar dacă ai făcut ceva, fix va fi ușor pentru a se potrivi în, din cauza programului structură clară. Chiar regex-programe grele ar trebui să aibă avem. Acum că s-a ieșit în cale, lasă-mă să abordeze OP întrebare.

Demo de Rezolvarea OP Sarcina Folosind Regexes

Mic `html_input_rx program am inclus mai jos produce următoarea ieșire, astfel încât să puteți vedea că parsarea HTML cu regexes funcționează foarte bine pentru ceea ce doriți să faceți: 

% 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://g-ecx.images-amazon.com/images/G/01/x-locale/common/transparent-pixel._V192234675_.gif"
        type => "image"

Analiza Input Tag-Uri, Nu Văd Nimic Rău De Intrare

Aici e sursa pentru programul care a produs rezultatul de mai sus. 

#!/usr/bin/env perl
#
# html_input_rx - pull out all <input> tags from (X)HTML src
#                  via simple regex processing
#
# Tom Christiansen <[email protected]>
# 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: $!";
}

Acolo te duci! Nimic la ea! :) Numai you poate judeca dacă-ți cunoștințele cu regexes este de până la o anumită analiză de sarcină. Toată lumea e nivelul de calificare este diferit, și fiecare nouă sarcină este diferită. Pentru locuri de munca unde aveti o bine-definit set de intrare, regexes sunt în mod evident dreptul de alegere, pentru că este ușor de a pune împreună atunci când aveți un subset limitat de HTML pentru a face față. Chiar regex incepatori ar trebui să se ocupe de aceste locuri de muncă cu regexes. Orice altceva este nejustificată. Cu toate acestea, odată HTML începe să devină mai puțin bătut în cuie, odată ce începe să se ramifica în moduri în care nu se poate anticipa, dar care sunt perfect legale, odată ce aveți pentru a se potrivi mai multe lucruri diferite sau cu mai multe dependențe complexe, în cele din urmă veți ajunge la un punct în care trebuie să lucreze mai greu pentru a efectua o soluție care folosește regexes decât tine ar trebui să utilizați o analiză de clasă. În cazul în care punctul de break-chiar cade depinde din nou pe propriul nivel de confort cu regexes. Deci, Ce Ar Trebui Să Fac?

Nu am de gând să-ți spun ce trebuie să faci sau ce nu nu. Cred că e Greșit. Vreau doar să vă prezentăm posibilitate, deschide ochii un pic. Veți obține pentru a alege ceea ce vrei să faci și cum vrei să faci asta. Nu există absoluturi — și nimeni nu-ți cunoaște propria situație la fel de bine ca tine faci. Dacă ceva pare ca e prea mult de lucru, ei bine, poate că este. Programarea ar trebui să fie fun, știi. Dacă nu, ați putea fi greșit. Se poate uita la mine `html_input_rx program în orice număr de moduri corecte. Una din ele este că, într-adevăr, poate parse HTML cu expresii regulate. Dar altul este că este mult, mult, mult mai greu decât oricine vreodată crede că este. Acest lucru poate duce cu ușurință la concluzia că programul meu este o marturie a ceea ce ar trebui să nu nu, pentru că într-adevăr este prea greu. Eu nu sunt de acord cu asta. Cu siguranță, dacă tot ceea ce fac în programul meu nu are sens pentru tine, după unele studii, atunci nu ar trebui să fie încercarea de a utiliza regexes pentru acest tip de sarcină. Pentru anumite HTML, regexes sunt mari, dar pentru generic HTML, acestea sunt echivalente cu nebunia. Eu folosesc parsarea clase tot timpul, mai ales daca e HTML nu m-am generat eu.

Regexes optime pentru mic HTML parsing probleme, pessimal pentru cele mari

Chiar daca programul meu este luat ca ilustrative de ce ar trebui să nu utilizarea regexes pentru parsarea HTML general — ceea ce este OK, pentru că am vrut să spun pentru a fi că ☺ — încă ar trebui să fie un ochi-deschis astfel încât mai multe persoane rupe foarte comune și urât, urât obiceiul de a scrie ilizibil, nestructurate, și unmaintainable modele. Modele nu trebuie să fie urât, și ei nu trebuie să fie greu. Dacă vă creați urât modele, este o reflecție pe tine, nu pe ei. Fenomenal Rafinat Regex Limba

Am fost rugat să subliniez că mi proferred soluție la problema ta a fost scris în Perl. Te-a surprins? N-ai observat? Este această revelație o bombă? Este adevărat că nu toate alte instrumente și limbaje de programare sunt destul de la fel de convenabil, expresiv și puternic atunci când vine vorba de regexes ca Perl este. E un mare spectru de acolo, cu unele mai potrivite decât altele. În general, limbile care și-au exprimat regexes ca parte din nucleul limbajului, în loc ca o bibliotecă sunt mai ușor de a lucra cu. N-am făcut nimic cu regexes că nu ai putea face în, să zicem, PCRE, deși ar structura programului diferit dacă ați fost utilizați C. În cele din urmă alte limbi vor fi prinde cu unde Perl este acum în termeni de regexes. Spun asta pentru că atunci când Perl început, nimeni nu a avut nimic ca Perl regexes. Spune ce vrei, dar acest lucru este în cazul în Perl câștigat clar: toata lumea a copiat Perl regexes deși la diferite etape ale dezvoltării lor. Perl pionier aproape (nu chiar toate, dar aproape) tot ce-ai venit să se bazeze pe în modelele moderne de azi, indiferent de ce instrument sau limba utilizată. Deci, în cele din urmă pe ceilalți va a prinde. Dar se vor prinde numai de unde Perl a fost cândva, în trecut, la fel cum este acum. Totul avansuri. În regexes dacă nimic altceva, în cazul în Perl duce, alții urmează. În cazul în care va Perl fi o dată toată lumea în cele din urmă prinde unde Perl este acum? N-am idee, dar știu că prea s-au mutat. Probabil vom fi mai aproape de Perl₆ stil de crafting modele. Dacă vă place acest tip de lucru, dar ar dori să-l folosească în Perl₅, ați putea fi interesat în Damian Conway minunat Regexp::Gramatici module. E absolut minunat, și de a face ceea ce am făcut aici, în programul meu părea la fel de primitiv ca al meu face modele pe care oamenii contopesc fără spațiu sau alfabetic de identificare. A verifica it afară!

HTML simplu Chunker

Aici este sursa completă a parser-am arătat piesa centrală de la începutul acestei postări. Eu sunt nu sugerând că ar trebui să utilizați acest peste un testate riguros de analiză de clasă. Dar m-am săturat de oameni care pretind că nimeni nu poate parse HTML cu regexes doar pentru ei nu se poate. Cu siguranță, și acest program este o dovadă a acestei afirmații. Sigur, nu e ușor, dar se se posibil! Și încercarea de a face acest lucru este o mare pierdere de timp, deoarece o bună analiză există clase care te ar trebui să utilizați pentru această sarcină. Răspunsul corect la oamenii încearcă să elimine arbitrare HTML este nu că este imposibil. Asta este un superficial și nesincer răspuns. Corect și cinstit răspunsul este că nu ar trebui să-l încerce, pentru că este prea mult de o deranja să-mi dau seama de la zero; ele nu ar trebui să rupe spatele lor străduindu-se să reïnvent o roată care funcționează foarte bine. Pe de altă parte, HTML care cade într-un termen previzibil subset este ultra-ușor pentru a analiza cu regexes. Nu e de mirare ca oamenii să încerce să le folosească, pentru că de mici probleme, jucărie probleme, probabil, nimic nu ar putea fi mai ușor. De aceea e atât de important să se distingă două sarcini specifice vs generic — ca acestea nu neapărat cererii aceeași abordare. Sper ca în viitor aici pentru a vedea o mult mai corect și onest tratament de întrebări despre HTML și regexes. Aici este meu HTML norrie. Nu încercați să facă o validare analiza; se identifică elemente lexicale. S-ar putea gândi la ea ca un HTML chunker decât un parser HTML. Nu e foarte iertătoare a rupt HTML, deși acesta face unele foarte mici cote în această direcție. Chiar daca nu ai parse HTML complet de tine (și de ce ar trebui? e o problemă rezolvată!), acest program are o mulțime de rece regex bits care cred că o mulțime de oameni pot învăța o mulțime de. Bucurați-vă de! 

#!/usr/bin/env perl
#
# chunk_HTML - a regex-based HTML chunker
#
# Tom Christiansen <[email protected]
#   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 }
Tudor Constantin
Tudor Constantin
Răspuns editat 24 octombrie 2019 в 12:33
675
Aveți o întrebare? Adăugați-o pe site-ul nostru și primiți răspuns instant
ro.kzen.dev
  1. Puteți scrie un roman ca tchrist făcut
  2. Puteți utiliza un DOM bibliotecă, încărcați HTML și de a folosi xpath și de a folosi doar //intrare[@type="ascunse"]. Sau, dacă nu't doriți să utilizați xpath, doar lua toate intrările și filtra cele care sunt ascunse cu getAttribute`.

Prefer #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>';
}

Rezultatul:

hide yo kids<br>hide yo wife<br>
meder omuraliev
meder omuraliev
Răspuns editat 20 noiembrie 2010 в 7:43
124
Aveți o întrebare? Adăugați-o pe site-ul nostru și primiți răspuns instant
ro.kzen.dev
Solution / Answer

Contrar toate răspunsurile aici, pentru ceea ce ai're încercarea de a face regex este perfect valabil soluție. Acest lucru este pentru că NU sunteți încercarea de a se potrivi echilibrat categorie ... ASTA ar fi imposibil cu regex! Dar sunt numai potrivite ce's într-o singură etichetă, și că's perfect regulate.

Aici's problema, totusi. Puteți't face doar cu un regex... aveți nevoie pentru a face un meci pentru a captura o `<input> tag, apoi face o prelucrare ulterioară pe asta. Rețineți că aceasta va funcționa doar dacă nici una dintre valorile atributului au o "> " personajul în ele, așa că's nu este perfect, dar ar trebui să fie suficient de sănătos intrări.

Aici's unele Perl (pseudo)cod pentru a arăta ce vreau să spun:

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
}

Principiul de bază aici este, don't încearcă să facă prea mult cu o expresie regulată. După cum ați observat, expresii regulate impune o anumită cantitate de comanda. Deci, ce trebuie să fac, în schimb, este la primul meci în CONTEXTUL a ceea ce ai're încercarea de a extrage, apoi face submatching pe datele pe care doriți.

EDIT: cu toate Acestea, eu sunt de acord că, în general, folosind un parser HTML este, probabil, mai ușor și mai bine și ar trebui să ia în considerare reproiectarea cod sau reevaluezi obiectivele. :-) Dar am avut de a posta acest raspuns ca un contor de reacție, care parsarea orice subset de HTML este imposibil: HTML și XML sunt atât de neregulate, atunci când ia în considerare întreaga caietul de sarcini, dar caietul de sarcini de o etichetă este decent regulat, cu siguranță, în puterea de PCRE.

Platinum Azure
Platinum Azure
Răspuns editat 8 iulie 2011 в 2:59
106

În spiritul Tom Christiansen's norrie soluție, aici's a link-ul de la Robert Cameron's aparent uitat 1998 articolul, REX: XML Superficial Parsarea cu Expresii Regulate.

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

Rezumat

sintaxa XML este destul de simplu că este posibil pentru a analiza un document XML într-o listă de marcare sale și a articolelor de text folosind o singură expresie regulată. Astfel o superficiala analiza a unui document XML poate fi foarte util pentru construirea de o varietate de ușor instrumente de procesare XML. Cu toate acestea, expresii regulate complexe pot fi dificil de construit și chiar mai dificil de citit. Folosind o formă de știință de carte de programare pentru expresii regulate, acest document de hârtie un set de XML superficială analiză expresii care pot fi utilizate pe bază de simple, corecte, eficiente, robuste și independentă de limbă XML superficial de analiză. Completați superficial parser implementări de mai puțin de 50 de linii, fiecare în Perl, JavaScript și Lex/Flex sunt, de asemenea, dat.

Dacă vă bucura de lectură despre expresii regulate, Cameron's de hârtie este fascinant. Scrisul său este concis, aprofundată, și foarte detaliate. El's nu pur și simplu care vă arată cum să construiască REX expresie regulată, dar, de asemenea, o abordare pentru construirea de complexe regex din părți mai mici.

Am'am fost folosind REX expresie regulată pe și în afara pentru 10 ani pentru a rezolva la fel de problema inițială poster întrebat despre (cum am meci special acest tag, dar nu un alt foarte similare de tag-ul?). Am'am găsit regex-a dezvoltat pentru a fi complet sigur.

REX este deosebit de util atunci când ai de're concentrându-se pe lexicale detalii de un document-de exemplu, atunci când transformă un tip de document de text (de exemplu, plain text, XML, SGML, HTML) într-un alt, în cazul în care documentul nu poate fi valabilă, bine formate, sau chiar parsable pentru cele mai multe de transformare. Acesta vă permite să țintă insule de marcare oriunde într-un document fără a deranja restul documentului.

Grodriguez
Grodriguez
Răspuns editat 20 noiembrie 2011 в 2:59
21
Aveți o întrebare? Adăugați-o pe site-ul nostru și primiți răspuns instant
ro.kzen.dev

În timp ce îmi place conținutul restul de aceste răspunsuri, au n't într-adevăr răspunde la întrebare în mod direct sau cât mai corect. Chiar Platină's răspunsul a fost prea complicat, și, de asemenea, mai puțin eficiente. Așa că am fost nevoit să pun asta.

Am'm un mare susținător al Regex, atunci când sunt utilizate corect. Dar din cauza stigmatului (și de performanță), mereu am stat bine format XML sau HTML, ar trebui să utilizați un Parser XML. Și performanță chiar mai bine ar fi string-parsarea, deși nu's o linie între lizibilitate cazul în care devine prea de-parte. Cu toate acestea, asta nu't la întrebare. Întrebarea este cum să se potrivească o ascunse-tip de intrare etichetă. Răspunsul este:

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

În funcție de aroma, doar regex opțiunea'd trebuie să includă este ignorecase opțiune.

7

puteți încerca acest lucru :

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

și mai aproape de rezultat, puteți să încercați acest lucru :

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

puteți testa regex model aici http://regexpal.com/

aceste pattens sunt bune pentru acest lucru:

<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="ascunse" nume="__VIEWSTATE0" value="3" /><input type="ascunse" nume="__VIEWSTATE" value="" /><input type="ascunse" nume="__VIEWSTATE" valoare="" />

și pentru ordine aleatorie de "tip", "nume" și "valoare" u pot folosi asta :

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

sau

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

pe aceasta :

<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" />
<input type="ascunse" nume="__VIEWSTATE" value="" /><input type="ascunse" nume="__VIEWSTATE" valoare="" /> `

apropo cred ca vrei ceva de genul asta :

<[ ]*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"[ ]*)+)[ ]*/>

nu e bine, dar funcționează în nici un fel.

testați-l în : http://regexpal.com/

Shamshirsaz.Navid
Shamshirsaz.Navid
Răspuns editat 31 martie 2013 в 9:33
3
Aveți o întrebare? Adăugați-o pe site-ul nostru și primiți răspuns instant
ro.kzen.dev

Aș dori să folosi **DOMDocument** pentru a extrage codul html.

$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, îl puteți testa aici regex101.com. Acesta arată rezultatul în timp real. Unele reguli despre Regexp: http://www.eclipse.org/tptp/home/downloads/installguide/gla_42/ref/rregexp.html Reader.

1

să presupunem că dvs. de conținut html sunt stocate în șir html apoi, în scopul de a obține fiecare intrare care conțin tip ascunse puteți utiliza expresii regulate

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

cele de mai sus regex găsi<inputurmat de către orice număr de caractere până când acesta devinetype="ascunse" sau tip='ascuns' urmat de către orice număr de caractere, până devine " >"

/g spune expresie regulată pentru a găsi fiecare subșir care se potrivește la modelul dat.

0
Aveți o întrebare? Adăugați-o pe site-ul nostru și primiți răspuns instant
ro.kzen.dev