Qual é a melhor maneira de selecionar todo o texto entre duas tags - ex: o texto entre todas as tags 'pré' na página.

Você pode usar "<pre>(.*?)</pre>"(substituindo pre pelo texto que desejar) e extrair o primeiro grupo (para instruções mais específicas, especificar um idioma), mas isso pressupõe a noção simplista de que você tem HTML muito simples e válido.

Como outros comentaristas sugeriram, se você estiver fazendo algo complexo, use um analisador de HTML.

A tag pode ser concluída em outra linha. É por isso que \nprecisa ser adicionado.

<PRE>(.|\n)*?<\/PRE>

Isto é o que eu usaria.

(?<=(<pre>))(\w|\d|\n|[().,\-:;@#$%^&*\[\]"'+–/\/®°⁰!?{}|`~]| )+?(?=(</pre>))

Basicamente, o que faz é:

(?<=(<pre>))A seleção deve ser precedida por uma <pre>tag

(\w|\d|\n|[().,\-:;@#$%^&*\[\]"'+–/\/®°⁰!?{}|~]| )Esta é apenas uma expressão regular que quero aplicar. Nesse caso, ele seleciona caracteres de letra ou dígito ou nova linha ou alguns caracteres especiais listados no exemplo entre colchetes. O caractere de pipe |significa simplesmente " OU ".

+?Os estados de caracteres positivos para selecionar uma ou mais das ordens acima não importam. O ponto de interrogação altera o comportamento padrão de 'ganancioso' para 'ingrato'.

(?=(</pre>))A seleção deve ser anexada pela </pre>tag

Dependendo do seu caso de uso, pode ser necessário adicionar alguns modificadores como ( i ou m )

• i - não diferencia maiúsculas de minúsculas
• m - pesquisa multilinhas

Aqui eu realizei essa pesquisa no Sublime Text para não precisar usar modificadores no meu regex.

Javascript não suporta lookbehind

O exemplo acima deve funcionar bem com linguagens como PHP, Perl, Java ... No entanto, o Javascript não suporta lookbehind, portanto, precisamos esquecer o uso (?<=(<pre>))e procurar algum tipo de solução alternativa. Talvez simples tira os quatro primeiros caracteres do nosso resultado para cada seleção, como aqui Regex corresponde ao texto entre as tags

Também olhar para o DOCUMENTAÇÃO JavaScript REGEX para parênteses não captura

use o padrão abaixo para obter conteúdo entre os elementos. Substitua [tag]pelo elemento real do qual você deseja extrair o conteúdo.

<[tag]>(.+?)</[tag]>

Em algum momento, as tags terão atributos, como anchortag href, e então use o padrão abaixo.

 <[tag][^>]*>(.+?)</[tag]>

Para excluir as tags de delimitação:

(?<=<pre>)(.*?)(?=</pre>)

(?<=<pre>) procura texto depois <pre>

(?=</pre>) procura texto antes </pre>

Os resultados serão inseridos na pretag

Você não deve tentar analisar html com expressões regulares, veja esta pergunta e como ela acabou.

Nos termos mais simples, o html não é uma linguagem comum, portanto você não pode analisar totalmente com expressões regulares.

Dito isto, você pode analisar subconjuntos de html quando não houver tags semelhantes aninhadas. Portanto, desde que algo entre e não seja essa tag em si, isso funcionará:

preg_match("/<([\w]+)[^>]*>(.*?)<\/\1>/", $subject, $matches);
$matches = array ( [0] => full matched string [1] => tag name [2] => tag content )

Uma idéia melhor é usar um analisador, como o DOMDocument nativo, para carregar seu html, selecione sua tag e obtenha o html interno que pode ser algo como isto:

$obj = new DOMDocument();
$obj -> load($html);
$obj -> getElementByTagName('el');
$value = $obj -> nodeValue();

E como esse é um analisador adequado, ele poderá manipular tags de aninhamento etc.

Tente isso ....

(?<=\<any_tag\>)(\s*.*\s*)(?=\<\/any_tag\>)

Esta parece ser a expressão regular mais simples de tudo o que encontrei

(?:<TAG>)([\s\S]*)(?:<\/TAG>)

1. Excluir etiqueta de abertura (?:<TAG>) das correspondências
2. Incluir caracteres em branco ou não em branco ([\s\S]*) em nas correspondências
3. Excluir marca de fechamento (?:<\/TAG>)das correspondências

Esta resposta supõe suporte para olhar ao redor! Isso me permitiu identificar todo o texto entre pares de tags de abertura e fechamento. Esse é todo o texto entre o '>' e o '<'. Funciona porque olhar ao redor não consome os caracteres correspondentes.

(? <=>) ([\ w \ s] +) (? = </)

Eu testei em https://regex101.com/ usando este fragmento HTML.

<table>
<tr><td>Cell 1</td><td>Cell 2</td><td>Cell 3</td></tr>
<tr><td>Cell 4</td><td>Cell 5</td><td>Cell 6</td></tr>
</table>

É um jogo de três partes: o olhar para trás, o conteúdo e o futuro.

(?<=>)    # look behind (but don't consume/capture) for a '>'
([\w\s]+) # capture/consume any combination of alpha/numeric/whitespace
(?=<\/)   # look ahead  (but don't consume/capture) for a '</'

Espero que sirva como ponto de partida para 10. Sorte.

var str = "Lorem ipsum <pre>text 1</pre> Lorem ipsum <pre>text 2</pre>";
    str.replace(/<pre>(.*?)<\/pre>/g, function(match, g1) { console.log(g1); });

Como a resposta aceita é sem código javascript, adicione isso:

preg_match_all(/<pre>([^>]*?)<\/pre>/,$content,$matches)esse regex selecionará tudo entre a tag. não importa se está em nova linha (trabalhe com várias linhas.

No Python, definir o DOTALLsinalizador capturará tudo, incluindo novas linhas.

Se o sinalizador DOTALL tiver sido especificado, ele corresponderá a qualquer caractere, incluindo uma nova linha. docs.python.org

#example.py using Python 3.7.4  
import re

str="""Everything is awesome! <pre>Hello,
World!
    </pre>
"""

# Normally (.*) will not capture newlines, but here re.DOTATLL is set 
pattern = re.compile(r"<pre>(.*)</pre>",re.DOTALL)
matches = pattern.search(str)

print(matches.group(1))

python example.py

Hello,
World!

Capturando texto entre todas as marcas de abertura e fechamento em um documento

Capturar texto entre todas as tags de abertura e fechamento de um documento finditeré útil. No exemplo abaixo, três <pre>tags de abertura e fechamento estão presentes na string.

#example2.py using Python 3.7.4
import re

# str contains three <pre>...</pre> tags
str = """In two different ex-
periments, the authors had subjects chat and solve the <pre>Desert Survival Problem</pre> with a
humorous or non-humorous computer. In both experiments the computer made pre-
programmed comments, but in study 1 subjects were led to believe they were interact-
ing with another person. In the <pre>humor conditions</pre> subjects received a number of funny
comments, for instance: “The mirror is probably too small to be used as a signaling
device to alert rescue teams to your location. Rank it lower. (On the other hand, it
offers <pre>endless opportunity for self-reflection</pre>)”."""

# Normally (.*) will not capture newlines, but here re.DOTATLL is set
# The question mark in (.*?) indicates non greedy matching.
pattern = re.compile(r"<pre>(.*?)</pre>",re.DOTALL)

matches = pattern.finditer(str)


for i,match in enumerate(matches):
    print(f"tag {i}: ",match.group(1))

python example2.py

tag 0:  Desert Survival Problem
tag 1:  humor conditions
tag 2:  endless opportunity for self-reflection

Para várias linhas:

<htmltag>(.+)((\s)+(.+))+</htmltag>

Você pode usar Pattern pattern = Pattern.compile( "[^<'tagname'/>]" );

Eu uso esta solução:

preg_match_all( '/<((?!<)(.|\n))*?\>/si',  $content, $new);
var_dump($new);

Em Javascript (entre outros), isso é simples. Abrange atributos e várias linhas:

/<pre[^>]*>([\s\S]*?)<\/pre>/

<pre>([\r\n\s]*(?!<\w+.*[\/]*>).*[\r\n\s]*|\s*[\r\n\s]*)<code\s+(?:class="(\w+|\w+\s*.+)")>(((?!<\/code>)[\s\S])*)<\/code>[\r\n\s]*((?!<\w+.*[\/]*>).*|\s*)[\r\n\s]*<\/pre>