¿Cuál es la mejor manera de seleccionar todo el texto entre 2 etiquetas? Por ejemplo: el texto entre todas las etiquetas 'pre' de la página.

Puede usar "<pre>(.*?)</pre>", (reemplazando pre por el texto que desee) y extraer el primer grupo (para obtener instrucciones más específicas, especifique un idioma), pero esto supone la noción simplista de que tiene HTML muy simple y válido.

Como han sugerido otros comentaristas, si está haciendo algo complejo, use un analizador HTML.

La etiqueta se puede completar en otra línea. Por eso es \nnecesario agregarlo.

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

Esto es lo que usaría.

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

Básicamente lo que hace es:

(?<=(<pre>))La selección tiene que anteponerse con la <pre>etiqueta

(\w|\d|\n|[().,\-:;@#$%^&*\[\]"'+–/\/®°⁰!?{}|~]| )Esta es solo una expresión regular que quiero aplicar. En este caso, selecciona letra o dígito o carácter de nueva línea o algunos caracteres especiales enumerados en el ejemplo entre corchetes. El carácter de la tubería |simplemente significa " O ".

+?Además de los estados de caracteres para seleccionar uno o más de los anteriores, el orden no importa. El signo de interrogación cambia el comportamiento predeterminado de "codicioso" a "no codicioso".

(?=(</pre>))La selección debe ser agregada por la </pre>etiqueta

Dependiendo de su caso de uso puede que tenga que añadir algunos modificadores como ( i o m )

• i - no distingue entre mayúsculas y minúsculas
• m - búsqueda multilínea

Aquí realicé esta búsqueda en Sublime Text para no tener que usar modificadores en mi expresión regular.

Javascript no es compatible con mirar atrás

El ejemplo anterior debería funcionar bien con lenguajes como PHP, Perl, Java ... Javascript, sin embargo, no admite mirar hacia atrás, por lo que debemos olvidarnos de usar (?<=(<pre>))y buscar algún tipo de solución alternativa. Tal vez simplemente elimine los primeros cuatro caracteres de nuestro resultado para cada selección, como aquí Texto de coincidencia de expresiones regulares entre etiquetas

También mire la DOCUMENTACIÓN JAVASCRIPT REGEX para paréntesis sin captura

use el siguiente patrón para obtener contenido entre elementos. Reemplace [tag]con el elemento real del que desea extraer el contenido.

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

Algunas veces las etiquetas tendrán atributos, como anchortener etiquetas href, luego use el patrón a continuación.

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

Para excluir las etiquetas delimitadoras:

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

(?<=<pre>) busca texto después <pre>

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

Los resultados enviarán un mensaje de texto dentro de la preetiqueta

No debería intentar analizar html con expresiones regulares, vea esta pregunta y cómo resultó.

En los términos más simples, html no es un lenguaje regular, por lo que no se puede analizar completamente con expresiones regulares.

Dicho esto, puede analizar subconjuntos de html cuando no hay etiquetas similares anidadas. Entonces, siempre que algo entre y no sea esa etiqueta en sí, esto funcionará:

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

Una mejor idea es usar un analizador, como el DOMDocument nativo, para cargar su html, luego seleccione su etiqueta y obtenga el html interno que podría verse así:

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

Y dado que este es un analizador adecuado, podrá manejar etiquetas de anidamiento, etc.

Prueba esto....

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

Esta parece ser la expresión regular más simple de todo lo que encontré

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

1. Excluir etiqueta de apertura (?:<TAG>)de los partidos
2. Incluya cualquier espacio en blanco o no espacios ([\s\S]*)en blanco en las coincidencias
3. Excluir etiqueta de cierre (?:<\/TAG>)de los partidos

¡Esta respuesta supone soporte para mirar alrededor! Esto me permitió identificar todo el texto entre pares de etiquetas de apertura y cierre. Ese es todo el texto entre el '>' y el '<'. Funciona porque mirar alrededor no consume los caracteres que coincide.

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

Lo probé en 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>

Es un juego de tres partes: la mirada hacia atrás, el contenido y la mirada hacia el 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 un comienzo para 10. Suerte.

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 la respuesta aceptada es sin código javascript, entonces agregue eso:

preg_match_all(/<pre>([^>]*?)<\/pre>/,$content,$matches)esta expresión regular seleccionará todo entre etiquetas. no importa si está en una nueva línea (trabajar con multilínea.

En Python, establecer la DOTALLbandera capturará todo, incluidas las nuevas líneas.

Si se ha especificado el indicador DOTALL, esto coincide con cualquier carácter, incluida una nueva línea. 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!

Captura de texto entre todas las etiquetas de apertura y cierre en un documento

Para capturar texto entre todas las etiquetas de apertura y cierre en un documento, finditeres útil. En el siguiente ejemplo, tres <pre>etiquetas de apertura y cierre están presentes en la cadena.

#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 múltiples líneas:

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

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

Yo uso esta solución:

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

En Javascript (entre otros), esto es simple. Cubre atributos y múltiples líneas:

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