您可以使用 ，（将 pre 替换为您想要的任何文本）并提取第一组（有关更具体的说明，请指定一种语言），但这假设您拥有非常简单和有效的 HTML。"<pre>(.*?)</pre>"

正如其他评论者所建议的那样，如果你正在做一些复杂的事情，请使用 HTML 解析器。

你不应该尝试用正则表达式解析html，看到这个问题以及结果如何。

简单来说，html 不是一种常规语言，因此您不能使用正则表达式完全解析 is。

话虽如此，当没有嵌套类似的标签时，您可以解析 html 的子集。因此，只要 和 之间的任何内容都不是该标签本身，这将起作用：

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

一个更好的主意是使用解析器（如本机 DOMDocument）来加载 html，然后选择您的标记并获取内部 html，它可能如下所示：

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

由于这是一个合适的解析器，它将能够处理嵌套标签等。

标记可以在另一行中完成。这就是需要添加的原因。\n

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

试试这个....

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

使用以下模式获取元素之间的内容。替换为要从中提取内容的实际元素。[tag]

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

有时标签会具有属性，例如标签具有 ，然后使用以下模式。anchorhref

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

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

对于多行：

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

这就是我会用的。

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

基本上它的作用是：

(?<=(<pre>))选择必须在前面加上标签<pre>

(\w|\d|\n|[().,\-:;@#$%^&*\[\]"'+–/\/®°⁰!?{}|~]| )这只是我想应用的正则表达式。在这种情况下，它选择字母或数字或换行符或方括号中列出的示例中列出的一些特殊字符。管道字符的意思是“OR”。|

+?加上字符状态来选择上述一个或多个 - 顺序无关紧要。问号将默认行为从“贪婪”更改为“unreedy”。

(?=(</pre>))选择必须附加到标签</pre>

根据您的用例，您可能需要添加一些修饰符，例如 （i 或 m)

• i - 不区分大小写
• M - 多行搜索

在这里，我在 Sublime Text 中执行了此搜索，因此我不必在正则表达式中使用修饰符。

Javascript 不支持 lookbehind

另请参阅 JAVASCRIPT REGEX DOCUMENTATION 了解非捕获括号

你可以使用Pattern pattern = Pattern.compile( "[^<'tagname'/>]" );

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

由于公认的答案没有 javascript 代码，因此添加：

我使用这个解决方案：

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

要排除分隔标记，请执行以下操作：

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

(?<=<pre>)在之后查找文本<pre>

(?=</pre>)查找之前的文本</pre>

结果将在标签内文本pre

这似乎是我发现的所有表达式中最简单的正则表达式

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

1. 从匹配项中排除开始标记(?:<TAG>)
2. 在匹配项中包含任何空格或非空格字符([\s\S]*)
3. 从匹配项中排除结束标记(?:<\/TAG>)

preg_match_all(/<pre>([^>]*?)<\/pre>/,$content,$matches)此正则表达式将选择 everyting between 标签。不管是在新行中（使用多行。

在 Python 中，设置标志将捕获所有内容，包括换行符。DOTALL

如果指定了 DOTALL 标志，则这将匹配包含换行符的任何字符。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!

捕获文档中所有开始和结束标记之间的文本

捕获文档中所有开始和结束标记之间的文本很有用。在下面的示例中，字符串中存在三个开始和结束标记。finditer<pre>

#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

这个答案假设支持环顾四周！这使我能够识别开始和结束标签对之间的所有文本。这就是“>”和“<”之间的所有文本。它之所以有效，是因为环顾四周不会消耗它匹配的字符。

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

我使用这个 HTML 片段在 https://regex101.com/ 年对其进行了测试。

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

这是一个由三个部分组成的游戏：回顾未来、内容和展望未来。

(?<=>)    # 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 '</'

我希望这能成为 10 的开始。运气。

在 Javascript（以及其他）中，这很简单。它涵盖属性和多行：

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

要选择我更喜欢的预标记之间的所有文本

preg_match('#<pre>([\w\W\s]*)</pre>#',$str,$matches);

$matches[0] 将包含包含<pre>标签的结果

$matches[1] 将包含所有内容 <pre>。

DomDocument 在要求在搜索的标签中获取带有标签详细信息的文本的情况下无法工作，因为它会剥离所有标签，nodeValue 和 textContent 将仅返回没有标签和属性的文本。

(?<=>)[^<]+

对于记事本++

>([^<]+)

for AutoIt（选项 Return array of global matchs）。

或

 (?=>([^<]+))

https://regex101.com/r/VtmEmY/1

const content = '<p class="title responsive">ABC</p>';
const blog = {content};
const re = /<([^> ]+)([^>]*)>([^<]+)(<\/\1>)/;
const matches = content.match(re);
console.log(matches[3]);

matches[3]是内容文本，这适用于任何带有类的标记名称。（不支持嵌套结构）

 test.match(/<pre>(.*?)<\/pre>/g)?.map((a) => a.replace(/<pre>|<\/pre>/g, ""))

这应该是首选解决方案。特别是当您在上下文中有多个 pre 标记时

怎么样：

<PRE>(\X*?)<\/PRE>

比 PyKing 的答案更复杂，但匹配任何类型的标签（自闭合除外），并考虑标签具有类似 HTML 的字符串属性的情况。

/<TAG_NAME(?:STRING|NOT_CLOSING_TAG_NOT_QUOTE)+>INNER_HTML<\/\1 *>/g

生：/<([^\s</>]+)(?:("(?:[^"\\]|\\.)*")|[^>"])+>(.*?)<\/\1 *>/g

正则表达式铁路图：

组 #1 = 标签名称

组 #2 = 字符串 attr

组 #3 = 内部 HTML

JavaScript 代码测试：

let TAG_NAME = '([^\s</>]+)';
let NOT_CLOSING_TAG_NOT_QUOTE = '[^>"]';
let STRING = '("(?:[^"\\\\]|\\\\.)*")';

let NON_SELF_CLOSING_HTML_TAG =
                                                              // \1 is a back reference to TAG_NAME
    `<${TAG_NAME}(?:${STRING}|${NOT_CLOSING_TAG_NOT_QUOTE})+>(.*?)</\\1 *>`;

let tagRegex = new RegExp(NON_SELF_CLOSING_HTML_TAG, 'g');

let myStr = `Aenean <abc href="/life<><>\\"<?/abc></abc>"><a>life</a></abc> sed consectetur.
<a href="/work">Work Inner HTML</a> quis risus eget <a href="/about">about inner html</a> leo.
interacted with any of the <<<ve text="<></ve>>">abc</ve>`;

let matches = myStr.match(tagRegex);

// Removing 'g' flag to match each tag part in the for loop
tagRegex = new RegExp(NON_SELF_CLOSING_HTML_TAG);

for (let i = 0; i < matches.length; i++) {
  let tagParts = matches[i].match(tagRegex);
  console.log(`Tag #${i} = [${tagParts[0]}]`);
  console.log(`Tag #${i} name: [${tagParts[1]}]`);
  console.log(`Tag #${i} string attr: [${tagParts[2]}]`);
  console.log(`Tag #${i} inner html: [${tagParts[3]}]`);
  console.log('');
}

输出：

Tag #0 = [<abc href="/life<><>\"<?/abc></abc>"><a>life</a></abc>]
Tag #0 name: [abc]
Tag #0 string attr: ["/life<><>\"<?/abc></abc>"]
Tag #0 inner html: [<a>life</a>]

Tag #1 = [<a href="/work">Work Inner HTML</a>]
Tag #1 name: [a]
Tag #1 string attr: ["/work"]
Tag #1 inner html: [Work Inner HTML]

Tag #2 = [<a href="/about">about inner html</a>]
Tag #2 name: [a]
Tag #2 string attr: ["/about"]
Tag #2 inner html: [about inner html]

Tag #3 = [<ve text="<></ve>>">abc</ve>]
Tag #3 name: [ve]
Tag #3 string attr: ["<></ve>>"]
Tag #3 inner html: [abc]

如果出现以下情况，则此操作不起作用：

• 该标记具有相同类型的任何后代标记
• 标记以一行开头，以另一行结束。（就我而言，我 从 HTML 中删除换行符）

如果您更改为它，即使所有内容都不在同一行中，它也应该与标签的内部 html 匹配。出于某种原因，它在 Chrome 和 Node 上对我不起作用，但在这里与 JavaScript 的正则表达式引擎一起工作：(.*?)<\/\1 *>([\s\S]*?)<\/\1 *>

https://www.regextester.com

正则表达式：<([^\s</>]+)(?:("(?:[^"\\]|\\.)*")|[^>"])+>([\s\S]*?)<\/\1 *>

测试字符串：

Aenean lacinia <abc href="/life<><><?/a></a>">  
<a>life</a></abc> sed consectetur.
<a href="/work">Work</a> quis risus eget urna mollis ornare <a href="/about">about</a> leo.
interacted with any of the <<<ve text="<></ve>>">abc</ve>