Preciso combinar todas essas tags de abertura:

<p>
<a href="foo">

Mas não estes:

<br />
<hr class="foo" />

Eu vim com isso e queria ter certeza de que estava certo. Estou apenas capturando o a-z.

<([a-z]+) *[^/]*?>

Eu acredito que diz:

• Encontre um menor que, então
• Encontre (e capture) az uma ou mais vezes, depois
• Encontre zero ou mais espaços e, em seguida,
• Encontre qualquer caractere zero ou mais vezes, ganancioso, exceto /, então
• Encontre um valor maior que

Eu tenho esse direito? E mais importante, o que você acha?

Você não pode analisar [X] HTML com regex. Porque o HTML não pode ser analisado pelo regex. Regex não é uma ferramenta que pode ser usada para analisar corretamente o HTML. Como já respondi às perguntas sobre HTML e regex aqui tantas vezes antes, o uso do regex não permitirá que você consuma HTML. Expressões regulares são uma ferramenta que não é suficientemente sofisticada para entender as construções empregadas pelo HTML. HTML não é uma linguagem regular e, portanto, não pode ser analisado por expressões regulares. As consultas Regex não estão equipadas para dividir o HTML em suas partes significativas. tantas vezes, mas isso não está me afetando. Mesmo expressões regulares irregulares aprimoradas, usadas pelo Perl, não têm a tarefa de analisar o HTML. Você nunca vai me fazer rachar. HTML é uma linguagem de complexidade suficiente que não pode ser analisada por expressões regulares. Mesmo Jon Skeet não pode analisar HTML usando expressões regulares. Toda vez que você tenta analisar HTML com expressões regulares, a criança profana chora o sangue de virgens, e hackers russos usam seu aplicativo da web. A análise de HTML com regex convoca almas contaminadas para o reino dos vivos. HTML e regex andam juntos como amor, casamento e infanticídio ritual. O <center> não pode aguentar, é tarde demais. A força de regex e HTML juntos no mesmo espaço conceitual destruirá sua mente como uma massa aquosa. Se você analisa HTML com regex, está cedendo a Eles e seus modos blasfemos que nos condenam a um trabalho desumano por Aquele cujo Nome não pode ser expresso no Plano Multilíngue Básico, ele chega. O HTML-mais-regexp irá liquefazer os sentimentos do senciente enquanto você observa, sua psique murcha no ataque de horror.É tarde demais É tarde demais Não podemos ser salvos A trangessão de uma criança garante que o regex consumirá todo o tecido vivo (exceto o HTML que não pode, como profetizado anteriormente) Caro senhor, ajude-nos como alguém pode sobreviver a esse flagelo usando o regex para analisar O HTML condenou a humanidade a uma eternidade de terríveis torturas e brechas de segurança, usando o rege x como uma ferramenta para processar o HTML estabelece uma brecha entre este mundo e o mundo das terríveis entidades corrompidas (como entidades SGML, mas mais corruptas), um mero vislumbre de o mundo da reg ex analisadores para HTML irá ins tantly transporte ap consciência de rogrammer i nto aw orl d de incessante gritando, ele vem, O pestilento sl wil ithy regex-infecção l devorar sua HT ML analisador, aplicação e existência de todos os tempos, como Visual Basic só que pior vier, com es não fi ght h e vem, oi s Unholy Radiance de stro҉ying toda a iluminação, HTML tags de vazamento fr̶ǫm yo ur olhos como liq uid p ain, a canção de Regular exp re análise ssion vai EXTI nguish as vozes de mor homem tal do sp aqui eu posso vê-lo você pode ver ele é bonito t ele f inal snuffing o f a mentira é do homem tudo está perdido a LL I SLOST th e pônei ele vir s ele COM es ele co me s t ele ich ou permeat es al l MEU FAC E MINHA CARA ᵒh deus n o NO NOO O ON Θ parada t ele um * ̶͑̾̾ GL ES ͎a̧͈͖r̽̾̈́͒͑en ot Rè̡͊͠͝aͨl̘̝̙̃ͤ͂̾̆ ZA̡͊͠͝LGΌ ISͮ̂҉̯͈͕̹̘̱ T O͇̹̺ͅƝ̴ȳ̳ TH̘ Ë͖́̉ ͠P̯͍̭O̚ N̐Y̡ H̸̡̪̯ͨ͊̽̅̾̎Ȩ̬̩̾͛ͪ̈́̀́͘ ̶̧̨̱̹̭̯ͧ̾ͬC̷̙̲̝͖ͭ̏ͥͮ͟Oͮ͏̮̪̝͍M̲̖͊̒ͪͩͬ̚̚͜Ȇ̴̟̟͙̞ͩ͌͝ S̨̥̫͎̭ͯ̿̔̀ͅ

Você já tentou usar um analisador XML?

Nota do Moderador

Esta postagem está bloqueada para evitar edições inadequadas no seu conteúdo. A postagem parece exatamente como deveria - não há problemas com seu conteúdo. Por favor, não sinalize para a nossa atenção.

Embora o HTML arbitrário com apenas uma regex seja impossível, às vezes é apropriado usá-los para analisar um conjunto limitado e conhecido de HTML.

Se você tiver um pequeno conjunto de páginas HTML das quais deseja coletar dados e depois colocar em um banco de dados, as expressões regulares poderão funcionar bem. Por exemplo, recentemente queria obter os nomes, partidos e distritos dos representantes federais australianos, que saí do site do Parlamento. Este foi um trabalho limitado e único.

Regexes funcionou muito bem para mim e foram muito rápidos de configurar.

Eu acho que a falha aqui é que HTML é uma gramática Chomsky Tipo 2 (gramática livre de contexto) e RegEx é uma gramática Chomsky Tipo 3 (gramática regular) . Como uma gramática do tipo 2 é fundamentalmente mais complexa do que uma gramática do tipo 3 (consulte a hierarquia de Chomsky ), é matematicamente impossível analisar o XML com o RegEx.

Mas muitos tentarão, alguns até reivindicarão sucesso - mas até outros encontrarem a falha e estragar tudo.

Não dê ouvidos a esses caras. Você pode analisar totalmente gramáticas sem contexto com regex se você dividir a tarefa em partes menores. Você pode gerar o padrão correto com um script que execute cada uma delas em ordem:

1. Resolva o problema de parada.
2. Quadrado um círculo.
3. Elabore o problema do vendedor ambulante em O (log n) ou menos. Se for mais do que isso, você ficará sem memória RAM e o mecanismo travará.
4. O padrão será muito grande, portanto, verifique se você possui um algoritmo que comprima sem perdas dados aleatórios.
5. Quase lá - apenas divida a coisa toda por zero. Mole-mole.

Ainda não terminei a última parte, mas sei que estou chegando perto. Ele continua jogando CthulhuRlyehWgahnaglFhtagnExceptions por algum motivo, então eu vou portá-lo para o VB 6 e usá-lo On Error Resume Next. Vou atualizar o código assim que investigar essa porta estranha que acabou de se abrir na parede. Hmm.

PS Pierre de Fermat também descobriu como fazê-lo, mas a margem em que ele estava escrevendo não era grande o suficiente para o código.

Isenção de responsabilidade : use um analisador, se tiver a opção. Dito isto...

Este é o regex que eu uso (!) Para corresponder às tags HTML:

<(?:"[^"]*"['"]*|'[^']*'['"]*|[^'">])+>

Pode não ser perfeito, mas eu executei esse código através de um muito HTML. Note que ele até captura coisas estranhas como <a name="badgenerator"">, que aparecem na web.

Acho que, para não corresponder às tags independentes, você pode querer usar o look-behind negativo de Kobi :

<(?:"[^"]*"['"]*|'[^']*'['"]*|[^'">])+(?<!/\s*)>

ou apenas combine se e se não estiver.

Para downvoters: Este é um código de trabalho de um produto real. Duvido que alguém que leia esta página tenha a impressão de que é socialmente aceitável usar expressões regulares em HTML.

Advertência : devo observar que esse regex ainda se decompõe na presença de blocos CDATA, comentários e elementos de script e estilo. A boa notícia é que você pode se livrar daqueles que usam um regex ...

Há pessoas que lhe dirão que a Terra é redonda (ou talvez a Terra seja um esferóide oblato, se quiserem usar palavras estranhas). Eles estão mentindo.

Há pessoas que lhe dirão que as expressões regulares não devem ser recursivas. Eles estão limitando você. Eles precisam subjugar você e o fazem mantendo-o na ignorância.

Você pode viver na realidade deles ou tomar a pílula vermelha.

Como Lord Marshal (ele é um parente da classe Marshal .NET?), Eu vi o Regex-Verse com base na pilha underverse e retornei com conhecimentos de poderes que você não pode imaginar. Sim, acho que havia um ou dois antigos protegendo-os, mas eles estavam assistindo futebol na TV, então não foi difícil.

Eu acho que o caso XML é bastante simples. O RegEx (na sintaxe .NET), desinflado e codificado em base64 para facilitar a compreensão por sua mente débil, deve ser algo como isto:
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As opções a serem definidas são RegexOptions.ExplicitCapture. O grupo de captura que você está procurando é ELEMENTNAME. Se o grupo de capturaERROR não estiver vazio, ocorreu um erro de análise e o Regex parou.

Se você tiver problemas para convertê-lo em um regex legível por humanos, isso deve ajudar:

static string FromBase64(string str)
{
    byte[] byteArray = Convert.FromBase64String(str);

    using (var msIn = new MemoryStream(byteArray))
    using (var msOut = new MemoryStream()) {
        using (var ds = new DeflateStream(msIn, CompressionMode.Decompress)) {
            ds.CopyTo(msOut);
        }

        return Encoding.UTF8.GetString(msOut.ToArray());
    }
}

Se você não tiver certeza, não, não estou brincando (mas talvez esteja mentindo). Vai funcionar. Criei toneladas de testes de unidade para testá-lo e até usei (parte) dos testes de conformidade . Como um tokenizador, não um analisador completo, ele só dividirá o XML em seus tokens de componente. Não analisará / integrará DTDs.

Ah ... se você quiser o código fonte da regex, com alguns métodos auxiliares:

regex para tokenizar um xml ou o regex comum completo

No shell, você pode analisar o HTML usando sed :

1. Turing.sed
2. Gravar analisador HTML (lição de casa)
3. ???
4. Lucro!

Relacionado (por que você não deve usar a correspondência de regex):

• Se você gosta tanto de expressões regulares, por que não se casa com elas?
• Expressões regulares: agora você tem dois problemas
• Hackeando o desinfetante HTML de stackoverflow.com

Concordo que a ferramenta certa para analisar XML e especialmente HTML é um analisador e não um mecanismo de expressão regular. No entanto, como outros já apontaram, algumas vezes o uso de um regex é mais rápido, fácil e o trabalho é feito se você souber o formato dos dados.

A Microsoft, na verdade, possui uma seção de Práticas recomendadas para expressões regulares no .NET Framework e fala especificamente sobre Considerar a fonte de entrada .

Expressões regulares têm limitações, mas você considerou o seguinte?

A estrutura .NET é única quando se trata de expressões regulares, pois oferece suporte a definições de grupo de balanceamento .

• Consulte Correspondência de construções balanceadas com expressões regulares do .NET
• Consulte Expressões regulares do .NET: Regex e correspondência equilibrada
• Consulte os documentos da Microsoft sobre Balancing Group Definitions

Por esse motivo, acredito que você PODE analisar o XML usando expressões regulares. Observe, no entanto, que ele deve ser XML válido (os navegadores perdoam muito o HTML e permitem uma sintaxe XML ruim dentro do HTML ). Isso é possível, pois a "Definição do grupo de balanceamento" permitirá que o mecanismo de expressão regular atue como um PDA.

Citação do artigo 1 citado acima:

Mecanismo de expressão regular do .NET

Conforme descrito acima, construções adequadamente balanceadas não podem ser descritas por uma expressão regular. No entanto, o mecanismo de expressão regular do .NET fornece algumas construções que permitem que construções equilibradas sejam reconhecidas.

• (?<group>) - envia o resultado capturado na pilha de captura com o grupo de nomes.
• (?<-group>) - exibe a captura mais superior com o grupo de nomes fora da pilha de captura.
• (?(group)yes|no) - corresponde à parte yes, se existir um grupo com o nome group, caso contrário não corresponde a nenhuma parte.

Essas construções permitem que uma expressão regular do .NET emule um PDA restrito, permitindo essencialmente versões simples das operações da pilha: push, pop e empty. As operações simples são praticamente equivalentes a incrementar, decrementar e comparar a zero, respectivamente. Isso permite que o mecanismo de expressão regular do .NET reconheça um subconjunto das linguagens sem contexto, em particular as que exigem apenas um contador simples. Isso, por sua vez, permite que expressões regulares do .NET não tradicionais reconheçam construções individuais adequadamente balanceadas.

Considere a seguinte expressão regular:

(?=<ul\s+id="matchMe"\s+type="square"\s*>)
(?>
   <!-- .*? -->                  |
   <[^>]*/>                      |
   (?<opentag><(?!/)[^>]*[^/]>)  |
   (?<-opentag></[^>]*[^/]>)     |
   [^<>]*
)*
(?(opentag)(?!))

Use as bandeiras:

• Única linha
• IgnorePatternWhitespace (não é necessário se você recolher regex e remover todo o espaço em branco)
• IgnoreCase (não necessário)

Expressão regular explicada (em linha)

(?=<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

Você pode tentar isso em A Better .NET Regular Expression Tester .

Eu usei a fonte de amostra de:

<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 &gt;ul&lt;, oh my!</li>
                    <li>...</li>
               </ul>
          </div>
      </li>
   </ul>
</div>
</body>
</html>

Isso encontrou a correspondência:

   <ul id="matchMe" type="square">
      <li>stuff...</li>
      <li>more stuff</li>
      <li>
          <div>
               <span>still more</span>
               <ul>
                    <li>Another &gt;ul&lt;, oh my!</li>
                    <li>...</li>
               </ul>
          </div>
      </li>
   </ul>

embora realmente tenha saído assim:

<ul id="matchMe" type="square">           <li>stuff...</li>           <li>more stuff</li>           <li>               <div>                    <span>still more</span>                    <ul>                         <li>Another &gt;ul&lt;, oh my!</li>                         <li>...</li>                    </ul>               </div>           </li>        </ul>

Por fim, gostei muito do artigo de Jeff Atwood: Parsing Html The Cthulhu Way . Engraçado o suficiente, ele cita a resposta a essa pergunta que atualmente tem mais de 4k votos.

Sugiro usar o QueryPath para analisar XML e HTML em PHP. É basicamente a mesma sintaxe do jQuery, mas é do lado do servidor.

Embora as respostas que você não pode analisar HTML com regexes estejam corretas, elas não se aplicam aqui. O OP só deseja analisar uma tag HTML com expressões regulares, e isso é algo que pode ser feito com uma expressão regular.

A regex sugerida está errada, no entanto:

<([a-z]+) *[^/]*?>

Se você adicionar algo ao regex, ao voltar atrás, ele poderá ser forçado a corresponder a coisas tolas como <a >>, [^/]é permissivo demais. Observe também que <space>*[^/]*é redundante, porque [^/]*também pode corresponder a espaços.

Minha sugestão seria

<([a-z]+)[^>]*(?<!/)>

Onde (?<! ... )está (em expressões regulares do Perl) o aspecto negativo. Ele lê "a <, então uma palavra, então qualquer coisa que não seja>, a última das quais pode não ser a /, seguida por>".

Observe que isso permite coisas como <a/ >(assim como o regex original); portanto, se você quiser algo mais restritivo, precisará criar um regex para corresponder aos pares de atributos separados por espaços.

Tentar:

<([^\s]+)(\s[^>]*?)?(?<!/)>

É semelhante ao seu, mas o último >não deve ser após uma barra e também aceita h1.

Sun Tzu, um antigo estrategista, general e filósofo chinês, disse:

Dizem que se você conhece seus inimigos e se conhece, pode vencer cem batalhas sem uma única perda. Se você apenas conhece a si mesmo, mas não o seu oponente, poderá ganhar ou perder. Se você não conhece a si mesmo nem a seu inimigo, sempre estará em perigo.

Nesse caso, seu inimigo é HTML e você é você ou regex. Você pode até ser Perl com regex irregular. Conheça HTML. Conheça a si mesmo.

Eu compus um haiku descrevendo a natureza do HTML.

HTML has
complexity exceeding
regular language.

Também compus um haiku descrevendo a natureza da regex no Perl.

The regex you seek
is defined within the phrase
<([a-zA-Z]+)(?:[^>]*[^/]*)?>

<?php
$selfClosing = explode(',', 'area,base,basefont,br,col,frame,hr,img,input,isindex,link,meta,param,embed');

$html = '
<p><a href="#">foo</a></p>
<hr/>
<br/>
<div>name</div>';

$dom = new DOMDocument();
$dom->loadHTML($html);
$els = $dom->getElementsByTagName('*');
foreach ( $els as $el ) {
    $nodeName = strtolower($el->nodeName);
    if ( !in_array( $nodeName, $selfClosing ) ) {
        var_dump( $nodeName );
    }
}

Resultado:

string(4) "html"
string(4) "body"
string(1) "p"
string(1) "a"
string(3) "div"

Basicamente, apenas defina os nomes dos nós dos elementos que se fecham automaticamente, carregue toda a cadeia html em uma biblioteca DOM, pegue todos os elementos, faça um loop e filtre os que não estão se fechando automaticamente e operam neles.

Tenho certeza que você já sabe que não deve usar regex para esse fim.

Eu não sei sua necessidade exata disso, mas se você também estiver usando o .NET, não poderia usar o Html Agility Pack ?

Excerto:

É uma biblioteca de códigos .NET que permite analisar arquivos HTML "fora da web". O analisador é muito tolerante com HTML malformado "mundo real".

Você deseja que o primeiro >não seja precedido por a /. Olha aqui detalhes sobre como fazer isso. É conhecido como lookbehind negativo.

No entanto, uma implementação ingênua disso acabará correspondendo <bar/></foo>neste documento de exemplo

<foo><bar/></foo>

Você pode fornecer um pouco mais de informação sobre o problema que está tentando resolver? Você está iterando pelas tags programaticamente?

O W3C explica a análise em um formato pseudo-regexp:
W3C Link

Siga os links var para QName,S e Attributepara obter uma imagem mais clara.
Com base nisso, você pode criar uma regexp muito boa para lidar com coisas como remover tags.

Se você precisar disso para PHP:

O DOM do PHP funções não funcionarão corretamente, a menos que sejam XML formatado corretamente. Não importa quão melhor seja o seu uso para o resto da humanidade.

simplehtmldom é bom, mas eu achei um pouco complicado, e é bastante memória pesada [Vai travar em páginas grandes.]

Eu nunca usei querypath , por isso não posso comentar sobre sua utilidade.

Outro a tentar é o meu DOMParser que é muito leve em relação aos recursos e estou usando felizmente há algum tempo. Simples de aprender e poderoso.

Para Python e Java, links semelhantes foram publicados.

Para os que recusaram - eu escrevi minha classe apenas quando os analisadores XML se mostraram incapazes de suportar o uso real. A votação religiosa apenas impede que respostas úteis sejam publicadas - mantenha as coisas dentro da perspectiva da pergunta, por favor.

Aqui está a solução:

<?php
// here's the pattern:
$pattern = '/<(\w+)(\s+(\w+)\s*\=\s*(\'|")(.*?)\\4\s*)*\s*(\/>|>)/';

// a string to parse:
$string = 'Hello, try clicking <a href="#paragraph">here</a>
    <br/>and check out.<hr />
    <h2>title</h2>
    <a name ="paragraph" rel= "I\'m an anchor"></a>
    Fine, <span title=\'highlight the "punch"\'>thanks<span>.
    <div class = "clear"></div>
    <br>';

// let's get the occurrences:
preg_match_all($pattern, $string, $matches, PREG_PATTERN_ORDER);

// print the result:
print_r($matches[0]);
?>

Para testá-lo profundamente, digitei as tags de fechamento automático da string, como:

1. <hr />
2. <br/>
3. <br>

Também inseri tags com:

1. um atributo
2. mais de um atributo
3. atributos cujo valor é vinculado entre aspas simples ou aspas duplas
4. atributos que contêm aspas simples quando o delimitador é uma aspas dupla e vice-versa
5. "despretty" atribui um espaço antes do símbolo "=", depois dele e antes e depois dele.

Se você encontrar algo que não funcione na prova de conceito acima, estou disponível na análise do código para melhorar minhas habilidades.

<EDIT> Esqueci que a pergunta do usuário era evitar a análise de tags de fechamento automático. Nesse caso, o padrão é mais simples, transformando-se no seguinte:

$pattern = '/<(\w+)(\s+(\w+)\s*\=\s*(\'|")(.*?)\\4\s*)*\s*>/';

O @ridgerunner usuário notou que o padrão não permite que atributos não cotadas ou atributos sem valor . Nesse caso, um ajuste fino nos traz o seguinte padrão:

$pattern = '/<(\w+)(\s+(\w+)(\s*\=\s*(\'|"|)(.*?)\\5\s*)?)*\s*>/';

</EDIT>

Compreendendo o padrão

Se alguém estiver interessado em aprender mais sobre o padrão, forneço uma linha:

1. a primeira subexpressão (\ w +) corresponde ao nome da tag
2. a segunda subexpressão contém o padrão de um atributo. É composto por:
   1. um ou mais espaços em branco \ s +
   2. o nome do atributo (\ w +)
   3. zero ou mais espaços em branco \ s * (é possível ou não, deixando espaços em branco aqui)
   4. o símbolo "="
   5. novamente, zero ou mais espaços em branco
   6. o delimitador do valor do atributo, aspas simples ou duplas ('| "). No padrão, a aspas simples é escapada porque coincide com o delimitador de string PHP. Essa sub-expressão é capturada com parênteses para que possa ser referenciada novamente para analisar o fechamento do atributo, é por isso que é muito importante.
   7. o valor do atributo, correspondido por quase qualquer coisa: (. *?); nessa sintaxe específica, usando a correspondência gananciosa (o ponto de interrogação após o asterisco), o mecanismo RegExp permite um operador semelhante ao "olhar à frente", que corresponde a qualquer coisa, exceto o que segue esta subexpressão
   8. aqui está a graça: a parte \ 4 é um operador de referência anterior , que se refere a uma subexpressão definida anteriormente no padrão; neste caso, estou me referindo à quarta subexpressão, que é o primeiro delimitador de atributo encontrado
   9. zero ou mais espaços em branco \ s *
   10. a subexpressão do atributo termina aqui, com a especificação de zero ou mais ocorrências possíveis, fornecidas pelo asterisco.
3. Então, como uma tag pode terminar com um espaço em branco antes do símbolo ">", zero ou mais espaços em branco são correspondidos com o subpadrão \ s *.
4. A tag a corresponder pode terminar com um simples símbolo ">" ou um possível fechamento XHTML, que utiliza a barra antes dela: (/> |>). A barra é, obviamente, escapada, uma vez que coincide com o delimitador da expressão regular.

Dica pequena: para analisar melhor esse código, é necessário examinar o código-fonte gerado, pois não forneci caracteres especiais HTML escapando.

Sempre que preciso extrair rapidamente algo de um documento HTML, uso o Tidy para convertê-lo em XML e depois XPath ou XSLT para obter o que eu preciso. No seu caso, algo como isto:

//p/a[@href='foo']

Eu usei uma ferramenta de código aberto chamada HTMLParser antes. Ele foi projetado para analisar o HTML de várias maneiras e serve muito bem ao objetivo. Ele pode analisar o HTML como um código de árvore diferente e você pode facilmente usar sua API para obter atributos fora do nó. Confira e veja se isso pode ajudá-lo.

Eu gosto de analisar HTML com expressões regulares. Não tento analisar HTML idiota que está deliberadamente quebrado. Este código é meu analisador principal (edição Perl):

$_ = join "",<STDIN>; tr/\n\r \t/ /s; s/</\n</g; s/>/>\n/g; s/\n ?\n/\n/g;
s/^ ?\n//s; s/ $//s; print

É chamado htmlsplit, divide o HTML em linhas, com uma tag ou parte do texto em cada linha. As linhas podem ser processadas ainda mais com outras ferramentas de texto e scripts, como grep , sed , Perl, etc. Eu nem estou brincando :) Aproveite.

É simples o suficiente para rejeitar meu script Perl slurp-everything-first em uma boa coisa de streaming, se você deseja processar enormes páginas da web. Mas não é realmente necessário.

Aposto que vou ser votado por isso.

Divisão HTML

Contra a minha expectativa, isso teve alguns votos positivos, então vou sugerir algumas expressões regulares melhores:

/(<.*?>|[^<]+)\s*/g    # get tags and text
/(\w+)="(.*?)"/g       # get attibutes

Eles são bons para XML / XHTML.

Com pequenas variações, ele pode lidar com HTML confuso ... ou converter o HTML -> XHTML primeiro.

A melhor maneira de escrever expressões regulares é no estilo Lex / Yacc , não como linhas opacas ou monstruosidades comentadas com várias linhas. Ainda não fiz isso aqui; esses mal precisam disso.

Aqui está um analisador baseado em PHP que analisa HTML usando algum regex ímpio. Como autor deste projeto, posso dizer que é possível analisar HTML com regex, mas não é eficiente. Se você precisar de uma solução do lado do servidor (como eu fiz para o meu plugin wp-Typography WordPress ), isso funcionará.

Existem algumas boas expressões para substituir o HTML pelo BBCode aqui . Para todos os que pensam mal, observe que ele não está tentando analisar completamente o HTML, apenas para higienizá-lo. Ele provavelmente pode se dar ao luxo de eliminar tags que seu simples "analisador" não consegue entender.

Por exemplo:

$store =~ s/http:/http:\/\//gi;
$store =~ s/https:/https:\/\//gi;
$baseurl = $store;

if (!$query->param("ascii")) {
    $html =~ s/\s\s+/\n/gi;
    $html =~ s/<pre(.*?)>(.*?)<\/pre>/\[code]$2\[\/code]/sgmi;
}

$html =~ s/\n//gi;
$html =~ s/\r\r//gi;
$html =~ s/$baseurl//gi;
$html =~ s/<h[1-7](.*?)>(.*?)<\/h[1-7]>/\n\[b]$2\[\/b]\n/sgmi;
$html =~ s/<p>/\n\n/gi;
$html =~ s/<br(.*?)>/\n/gi;
$html =~ s/<textarea(.*?)>(.*?)<\/textarea>/\[code]$2\[\/code]/sgmi;
$html =~ s/<b>(.*?)<\/b>/\[b]$1\[\/b]/gi;
$html =~ s/<i>(.*?)<\/i>/\[i]$1\[\/i]/gi;
$html =~ s/<u>(.*?)<\/u>/\[u]$1\[\/u]/gi;
$html =~ s/<em>(.*?)<\/em>/\[i]$1\[\/i]/gi;
$html =~ s/<strong>(.*?)<\/strong>/\[b]$1\[\/b]/gi;
$html =~ s/<cite>(.*?)<\/cite>/\[i]$1\[\/i]/gi;
$html =~ s/<font color="(.*?)">(.*?)<\/font>/\[color=$1]$2\[\/color]/sgmi;
$html =~ s/<font color=(.*?)>(.*?)<\/font>/\[color=$1]$2\[\/color]/sgmi;
$html =~ s/<link(.*?)>//gi;
$html =~ s/<li(.*?)>(.*?)<\/li>/\[\*]$2/gi;
$html =~ s/<ul(.*?)>/\[list]/gi;
$html =~ s/<\/ul>/\[\/list]/gi;
$html =~ s/<div>/\n/gi;
$html =~ s/<\/div>/\n/gi;
$html =~ s/<td(.*?)>/ /gi;
$html =~ s/<tr(.*?)>/\n/gi;

$html =~ s/<img(.*?)src="(.*?)"(.*?)>/\[img]$baseurl\/$2\[\/img]/gi;
$html =~ s/<a(.*?)href="(.*?)"(.*?)>(.*?)<\/a>/\[url=$baseurl\/$2]$4\[\/url]/gi;
$html =~ s/\[url=$baseurl\/http:\/\/(.*?)](.*?)\[\/url]/\[url=http:\/\/$1]$2\[\/url]/gi;
$html =~ s/\[img]$baseurl\/http:\/\/(.*?)\[\/img]/\[img]http:\/\/$1\[\/img]/gi;

$html =~ s/<head>(.*?)<\/head>//sgmi;
$html =~ s/<object>(.*?)<\/object>//sgmi;
$html =~ s/<script(.*?)>(.*?)<\/script>//sgmi;
$html =~ s/<style(.*?)>(.*?)<\/style>//sgmi;
$html =~ s/<title>(.*?)<\/title>//sgmi;
$html =~ s/<!--(.*?)-->/\n/sgmi;

$html =~ s/\/\//\//gi;
$html =~ s/http:\//http:\/\//gi;
$html =~ s/https:\//https:\/\//gi;

$html =~ s/<(?:[^>'"]*|(['"]).*?\1)*>//gsi;
$html =~ s/\r\r//gi;
$html =~ s/\[img]\//\[img]/gi;
$html =~ s/\[url=\//\[url=/gi;

Sobre a questão dos métodos RegExp para analisar (x) HTML, a resposta para todos que falaram sobre alguns limites é: você não foi treinado o suficiente para governar a força dessa arma poderosa, já que NINGUÉM aqui falou sobre recursão .

Um colega independente de RegExp me notificou essa discussão, que certamente não é a primeira na web sobre esse tópico antigo e popular.

Depois de ler algumas postagens, a primeira coisa que fiz foi procurar a string "? R" neste segmento. O segundo foi pesquisar sobre "recursão".
Não, vaca sagrada, nenhuma correspondência encontrada.
Como ninguém mencionou o mecanismo principal no qual um analisador é construído, logo percebi que ninguém entendia o ponto.

Se um analisador HTML (x) precisar de recursão, um analisador RegExp sem recursão não será suficiente para esse fim. É uma construção simples.

A arte negra do RegExp é difícil de dominar , portanto, talvez haja outras possibilidades que deixamos de fora ao testar e testar nossa solução pessoal para capturar toda a web em uma mão ... Bem, tenho certeza disso :)

Aqui está o padrão mágico:

$pattern = "/<([\w]+)([^>]*?)(([\s]*\/>)|(>((([^<]*?|<\!\-\-.*?\-\->)|(?R))*)<\/\\1[\s]*>))/s";

Apenas tente.
Ele é escrito como uma string PHP, então o modificador "s" faz com que as classes incluam novas linhas.
Aqui está um exemplo de nota no manual do PHP que escrevi em janeiro: Referência

(Cuidado, nessa nota, usei incorretamente o modificador "m"; ele deve ser apagado, apesar de ser descartado pelo mecanismo RegExp, pois não foi usada nenhuma ancoragem ^ ou $).

Agora, poderíamos falar sobre os limites desse método de um ponto de vista mais informado:

1. de acordo com a implementação específica do mecanismo RegExp, a recursão pode ter um limite no número de padrões aninhados analisados , mas depende do idioma usado
2. embora o HTML corrompido (x) não leve a erros graves, ele não é higienizado .

De qualquer forma, é apenas um padrão RegExp, mas revela a possibilidade de desenvolver muitas implementações poderosas.
Eu escrevi esse padrão para alimentar o analisador de descida recursiva de um mecanismo de modelo que construí em minha estrutura, e os desempenhos são realmente ótimos, tanto em tempos de execução quanto no uso de memória (nada a ver com outros mecanismos de modelo que usam a mesma sintaxe).

Como muitas pessoas já apontaram, o HTML não é uma linguagem comum, o que pode dificultar a análise. Minha solução para isso é transformá-lo em uma linguagem comum usando um programa organizado e, em seguida, usar um analisador XML para consumir os resultados. Existem muitas boas opções para isso. Meu programa é escrito usando Java com a biblioteca jtidy para transformar o HTML em XML e, em seguida, o Jaxen para xpath no resultado.

<\s*(\w+)[^/>]*>

As partes explicadas:

<: personagem inicial

\s*: pode ter espaços em branco antes do nome da tag (feio, mas possível).

(\w+): as tags podem conter letras e números (h1). Bem, \wtambém corresponde a '_', mas não dói, eu acho. Se curioso, use ([a-zA-Z0-9] +).

[^/>]*: qualquer coisa, exceto >e /até fechar>

>: fechamento >

NÃO RETIRADO

E aos colegas que subestimam as expressões regulares dizendo que são tão poderosos quanto as línguas comuns:

um ⁿ ba ⁿ ba ⁿ que não é regular e nem mesmo livre de contexto, pode ser combinado com^(a+)b\1b\1$

Backreferencing FTW !

Se você está simplesmente tentando encontrar essas tags (sem ambições de análise), tente esta expressão regular:

/<[^/]*?>/g

Escrevi em 30 segundos e testei aqui: http://gskinner.com/RegExr/

Ele corresponde aos tipos de tags que você mencionou, enquanto ignora os tipos que você disse que deseja ignorar.

Parece-me que você está tentando combinar tags sem um "/" no final. Tente o seguinte:

<([a-zA-Z][a-zA-Z0-9]*)[^>]*(?<!/)>

É verdade que, ao programar, geralmente é melhor usar analisadores e APIs dedicados em vez de expressões regulares ao lidar com HTML, especialmente se a precisão é primordial (por exemplo, se o seu processamento pode ter implicações de segurança). No entanto, não atribuo a uma visão dogmática de que a marcação no estilo XML nunca deve ser processada com expressões regulares. Há casos em que expressões regulares são uma ótima ferramenta para o trabalho, como ao editar edições únicas em um editor de texto, corrigir arquivos XML quebrados ou lidar com formatos de arquivos que parecem, mas não são, completamente XML. Há alguns problemas a serem observados, mas eles não são intransponíveis ou mesmo necessariamente relevantes.

Uma regex simples como <([^>"']|"[^"]*"|'[^']*')*>geralmente é boa o suficiente, em casos como os que acabei de mencionar. É uma solução ingênua, considerando todas as coisas, mas permite corretamente >símbolos não codificados nos valores dos atributos. Se você estiver procurando, por exemplo, uma tableetiqueta, poderá adaptá-la como </?table\b([^>"']|"[^"]*"|'[^']*')*>.

Apenas para dar uma idéia de como seria uma regex HTML mais "avançada", o seguinte faz um trabalho bastante respeitável de emular o comportamento do navegador do mundo real e o algoritmo de análise HTML5:

</?([A-Za-z][^\s>/]*)(?:=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)|[^>])*(?:>|$)

A seguir, uma definição bastante estrita de tags XML (embora não represente o conjunto completo de caracteres Unicode permitidos nos nomes XML):

<(?:([_:A-Z][-.:\w]*)(?:\s+[_:A-Z][-.:\w]*\s*=\s*(?:"[^"]*"|'[^']*'))*\s*/?|/([_:A-Z][-.:\w]*)\s*)>

É verdade que isso não explica o contexto circundante e alguns casos extremos, mas mesmo essas coisas poderiam ser tratadas se você realmente quisesse (por exemplo, pesquisando entre as correspondências de outra regex).

No final do dia, use a ferramenta mais apropriada para o trabalho, mesmo nos casos em que essa ferramenta for uma regex.

Embora não seja adequado e eficaz usar expressões regulares para esse fim, às vezes expressões regulares fornecem soluções rápidas para problemas simples de correspondência e, na minha opinião, não é tão horrível usar expressões regulares para trabalhos triviais.

Há um post definitivo no blog sobre a correspondência de elementos HTML mais internos, escritos por Steven Levithan.