You, know...there's a lot of mentality of you CAN'T do it and I think that everyone on both sides of the fence are right and wrong. You CAN do it, but it takes a little more processing than just running one regex against it. Take this (I wrote this inside of an hour) as an example. It assumes the HTML is completely valid, but depending on what language you're using to apply the aforementioned regex, you could do some fixing of the HTML to make sure that it will succeed. For example, removing closing tags that are not supposed to be there: </img> for example. Then, add the closing single HTML forward slash to elements that are missing them, etc.

我将在编写一个库的上下文中使用它，该库允许我执行类似于JavaScript的[x]. getelementsbytagname()的HTML元素检索。我只是拼接了我在正则表达式的DEFINE部分中编写的功能，并使用它来进入元素树，一次一个。

那么，这将是验证HTML的最终100%答案吗?不。但这只是个开始，只要再努力一点，就可以做到。然而，试图在一个正则表达式执行中完成它是不实际的，也不有效。

正则表达式并不是为处理嵌套的标记结构而设计的，要处理真正HTML中可能出现的所有边缘情况，往好里说是复杂的(往坏里说是不可能的)。

对于快速´n´dirty regexp就可以了。但是要知道的基本问题是，不可能构造一个正确解析HTML的regexp。

原因是regexp不能处理任意嵌套的表达式。参见正则表达式能否用于匹配嵌套模式?

Actually, HTML parsing with regex is perfectly possible in PHP. You just have to parse the whole string backwards using strrpos to find < and repeat the regex from there using ungreedy specifiers each time to get over nested tags. Not fancy and terribly slow on large things, but I used it for my own personal template editor for my website. I wasn't actually parsing HTML, but a few custom tags I made for querying database entries to display tables of data (my <#if()> tag could highlight special entries this way). I wasn't prepared to go for an XML parser on just a couple of self created tags (with very non-XML data within them) here and there.

所以，即使这个问题已经死了，它仍然会出现在谷歌搜索中。我读了它，并认为“接受挑战”，并完成了修复我的简单代码，而不需要替换所有东西。决定给有类似理由的人提供不同的意见。最后一个答案是4小时前发布的，所以这仍然是一个热门话题。

HTML/XML分为标记和内容。 Regex只对词法标记解析有用。 我想你可以推断出内容。 对于SAX解析器来说，这是一个很好的选择。 标签和内容可以传递给用户 定义了嵌套/闭包元素的函数 可以被追踪。

只要解析标记就可以了 正则表达式，用于从文档中删除标记。

经过多年的测试，我发现了秘密 浏览器解析标签的方式，包括良好的和不良的形式。

普通元素的解析形式如下:

这些标记的核心使用这个正则表达式

 (?:
      " [\S\s]*? " 
   |  ' [\S\s]*? ' 
   |  [^>]? 
 )+

你会注意到这个[^>]?作为一种替代。 这将匹配格式不正确的标签中的不平衡引号。

它也是正则表达式的所有邪恶之源。 它的使用方式将触发一个碰撞，以满足它的贪婪，必须匹配 量化的容器。

如果被动地使用，就永远不会有问题 但是，如果你通过穿插一些东西来强制匹配 一个需要的属性/值对，并且没有提供足够的保护 从回溯来看，这是一场失控的噩梦。

这是普通旧标签的一般形式。 注意到代表标记名称的[\w:]了吗? 实际上，表示标记名称的合法字符 是一个难以置信的Unicode字符列表。

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

继续前进，我们还看到您不能搜索特定的标记 无需解析所有标记。 我的意思是你可以，但它必须使用的组合 像(*SKIP)(*FAIL)这样的动词，但仍然必须解析所有标签。

原因是标记语法可能隐藏在其他标记中，等等。

因此，要被动地解析所有标签，需要一个如下所示的正则表达式。 这个特殊的匹配不可见内容。

作为新的HTML或xml或任何其他开发的新结构，只需将其添加为 其中一种变化。

网页注释-我从未见过一个网页(或xhtml/xml)，这 有麻烦。如果你找到了，请告诉我。

性能说明-它很快。这是我见过的最快的标记解析器 (也许会更快，谁知道呢)。 我有几个具体的版本。它也是优秀的刮板 (如果你是亲力亲为的类型)。

完成原始正则表达式

<(?:(?:(?:( applet | style |物体|脚本嵌入| | noframes | noscript | noembed) (: \ s + (? > [s \ s] * ?”|’s \ s ]*?'|(?:(?!/>)[^>])?)+)?\ s * >) [s \ ' s] * ? < / 1 \ s *(?=>))|(?:/?[\ w: +] \ s */?)|(?:[\ w: + s + s(?):“\ \ s] * ?’”| [s \ ]*?'|[^>]?)+\ s * / ?) | " s \ \ ? [ ]*?\?|(?:!(?:(?: DOCTYPE [S \ S ]*?)|(?:\[ CDATA [S \ \ S ]*?\]\])|(?:--[\ S \ ]*?--)|(?: ATTLIST [S \ S] *) |(?:实体[S \ S] *) |(?:元素[S \ S] * ?)) >

格式化的看

 <
 (?:
      (?:
           (?:
                # Invisible content; end tag req'd
                (                             # (1 start)
                     script
                  |  style
                  |  object
                  |  embed
                  |  applet
                  |  noframes
                  |  noscript
                  |  noembed 
                )                             # (1 end)
                (?:
                     \s+ 
                     (?>
                          " [\S\s]*? "
                       |  ' [\S\s]*? '
                       |  (?:
                               (?! /> )
                               [^>] 
                          )?
                     )+
                )?
                \s* >
           )

           [\S\s]*? </ \1 \s* 
           (?= > )
      )

   |  (?: /? [\w:]+ \s* /? )
   |  (?:
           [\w:]+ 
           \s+ 
           (?:
                " [\S\s]*? " 
             |  ' [\S\s]*? ' 
             |  [^>]? 
           )+
           \s* /?
      )
   |  \? [\S\s]*? \?
   |  (?:
           !
           (?:
                (?: DOCTYPE [\S\s]*? )
             |  (?: \[CDATA\[ [\S\s]*? \]\] )
             |  (?: -- [\S\s]*? -- )
             |  (?: ATTLIST [\S\s]*? )
             |  (?: ENTITY [\S\s]*? )
             |  (?: ELEMENT [\S\s]*? )
           )
      )
 )
 >

两个简单的原因:

编写一个能够抵御恶意输入的正则表达式是困难的;比使用预先构建的工具难多了 编写一个正则表达式来处理你不可避免地会遇到的荒谬的标记是困难的;比使用预先构建的工具难多了

关于正则表达式在解析中的适用性:它们并不合适。您是否见过解析大多数语言所需的正则表达式类型?