截断包含 HTML 的文本，忽略标签

Question

我想截断一些文本（从数据库或文本文件加载），但它包含 HTML，因此包含标签并且返回的文本较少。 这可能会导致标签未关闭或部分关闭（因此 Tidy 可能无法正常工作并且内容仍然较少）。 我如何根据文本进行截断（当您到达表格时可能会停止，因为这可能会导致更复杂的问题）。

substr("Hello, my <strong>name</strong> is <em>Sam</em>. I&acute;m a web developer.",0,26)."..."

会导致：

Hello, my <strong>name</st...

我想要的是：

Hello, my <strong>name</strong> is <em>Sam</em>. I&acute;m...

我该怎么做？

虽然我的问题是如何在 PHP 中执行此操作，但最好知道如何在 C# 中执行此操作...两者都应该没问题，因为我认为我能够将该方法移植过来（除非它是内置的）方法）。

另请注意，我已经包含了一个 HTML 实体 ´ - 必须将其视为单个字符（而不是本示例中的 7 个字符）。

strip_tags 是一个后备方案，但我会丢失格式和链接，而且 HTML 实体仍然存在问题。

Answer 1

Bounce 为 Søren Løvborg 的解决方案添加了多字节字符支持 - 我添加了：

• 对不配对 HTML 标记的支持（例如
  

  ---

  、
等不会被关闭 - 在 HTML 中，这些末尾不需要“/”（尽管在 XHTML 中是这样）），
• 可自定义截断指示符（默认为 & hellips; ie … ），
• 以字符串形式返回，不使用输出缓冲区，并
• 进行 100% 覆盖率的单元测试。

所有这些都在Pastie。

Answer 2

假设您使用有效的 XHTML，那么解析 HTML 并确保正确处理标签就很简单。 您只需跟踪到目前为止已打开的标签，并确保“在退出时”再次关闭它们。

<?php
header('Content-type: text/plain; charset=utf-8');

function printTruncated($maxLength, $html, $isUtf8=true)
{
    $printedLength = 0;
    $position = 0;
    $tags = array();

    // For UTF-8, we need to count multibyte sequences as one character.
    $re = $isUtf8
        ? '{</?([a-z]+)[^>]*>|&#?[a-zA-Z0-9]+;|[\x80-\xFF][\x80-\xBF]*}'
        : '{</?([a-z]+)[^>]*>|&#?[a-zA-Z0-9]+;}';

    while ($printedLength < $maxLength && preg_match($re, $html, $match, PREG_OFFSET_CAPTURE, $position))
    {
        list($tag, $tagPosition) = $match[0];

        // Print text leading up to the tag.
        $str = substr($html, $position, $tagPosition - $position);
        if ($printedLength + strlen($str) > $maxLength)
        {
            print(substr($str, 0, $maxLength - $printedLength));
            $printedLength = $maxLength;
            break;
        }

        print($str);
        $printedLength += strlen($str);
        if ($printedLength >= $maxLength) break;

        if ($tag[0] == '&' || ord($tag) >= 0x80)
        {
            // Pass the entity or UTF-8 multibyte sequence through unchanged.
            print($tag);
            $printedLength++;
        }
        else
        {
            // Handle the tag.
            $tagName = $match[1][0];
            if ($tag[1] == '/')
            {
                // This is a closing tag.

                $openingTag = array_pop($tags);
                assert($openingTag == $tagName); // check that tags are properly nested.

                print($tag);
            }
            else if ($tag[strlen($tag) - 2] == '/')
            {
                // Self-closing tag.
                print($tag);
            }
            else
            {
                // Opening tag.
                print($tag);
                $tags[] = $tagName;
            }
        }

        // Continue after the tag.
        $position = $tagPosition + strlen($tag);
    }

    // Print any remaining text.
    if ($printedLength < $maxLength && $position < strlen($html))
        print(substr($html, $position, $maxLength - $printedLength));

    // Close any open tags.
    while (!empty($tags))
        printf('</%s>', array_pop($tags));
}


printTruncated(10, '<b><Hello></b> <img src="world.png" alt="" /> world!'); print("\n");

printTruncated(10, '<table><tr><td>Heck, </td><td>throw</td></tr><tr><td>in a</td><td>table</td></tr></table>'); print("\n");

printTruncated(10, "<em><b>Hello</b>w\xC3\xB8rld!</em>"); print("\n");

编码说明：以上代码假设 XHTML 为 UTF-8< /a> 编码。 还支持 ASCII 兼容的单字节编码（例如 Latin-1），只需传递 false 作为第三个参数。 不支持其他多字节编码，但您可以通过在调用函数之前使用 mb_convert_encoding 转换为 UTF-8，然后在每个 print 语句中再次转换回来来支持。

（不过，您应该始终使用UTF-8。）

编辑：已更新以处理字符实体和UTF-8。 修复了如果该字符是字符实体，该函数会打印过多一个字符的错误。

Answer 3

我已经编写了一个函数，按照您的建议截断 HTML，但它没有将其打印出来，而是将其全部保留在字符串变量中。 也处理 HTML 实体。

 /**
     *  function to truncate and then clean up end of the HTML,
     *  truncates by counting characters outside of HTML tags
     *  
     *  @author alex lockwood, alex dot lockwood at websightdesign
     *  
     *  @param string $str the string to truncate
     *  @param int $len the number of characters
     *  @param string $end the end string for truncation
     *  @return string $truncated_html
     *  
     *  **/
        public static function truncateHTML($str, $len, $end = '…'){
            //find all tags
            $tagPattern = '/(<\/?)([\w]*)(\s*[^>]*)>?|&[\w#]+;/i';  //match html tags and entities
            preg_match_all($tagPattern, $str, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER );
            //WSDDebug::dump($matches); exit; 
            $i =0;
            //loop through each found tag that is within the $len, add those characters to the len,
            //also track open and closed tags
            // $matches[$i][0] = the whole tag string  --the only applicable field for html enitities  
            // IF its not matching an &htmlentity; the following apply
            // $matches[$i][1] = the start of the tag either '<' or '</'  
            // $matches[$i][2] = the tag name
            // $matches[$i][3] = the end of the tag
            //$matces[$i][$j][0] = the string
            //$matces[$i][$j][1] = the str offest

            while($matches[$i][0][1] < $len && !empty($matches[$i])){

                $len = $len + strlen($matches[$i][0][0]);
                if(substr($matches[$i][0][0],0,1) == '&' )
                    $len = $len-1;


                //if $matches[$i][2] is undefined then its an html entity, want to ignore those for tag counting
                //ignore empty/singleton tags for tag counting
                if(!empty($matches[$i][2][0]) && !in_array($matches[$i][2][0],array('br','img','hr', 'input', 'param', 'link'))){
                    //double check 
                    if(substr($matches[$i][3][0],-1) !='/' && substr($matches[$i][1][0],-1) !='/')
                        $openTags[] = $matches[$i][2][0];
                    elseif(end($openTags) == $matches[$i][2][0]){
                        array_pop($openTags);
                    }else{
                        $warnings[] = "html has some tags mismatched in it:  $str";
                    }
                }


                $i++;

            }

            $closeTags = '';

            if (!empty($openTags)){
                $openTags = array_reverse($openTags);
                foreach ($openTags as $t){
                    $closeTagString .="</".$t . ">"; 
                }
            }

            if(strlen($str)>$len){
                // Finds the last space from the string new length
                $lastWord = strpos($str, ' ', $len);
                if ($lastWord) {
                    //truncate with new len last word
                    $str = substr($str, 0, $lastWord);
                    //finds last character
                    $last_character = (substr($str, -1, 1));
                    //add the end text
                    $truncated_html = ($last_character == '.' ? $str : ($last_character == ',' ? substr($str, 0, -1) : $str) . $end);
                }
                //restore any open tags
                $truncated_html .= $closeTagString;


            }else
            $truncated_html = $str;


            return $truncated_html; 
        }

Answer 4

在这种情况下，可以使用 DomDocument 进行令人讨厌的正则表达式黑客攻击，最糟糕的是，如果标签损坏，会出现警告：

$dom = new DOMDocument();
$dom->loadHTML(substr("Hello, my <strong>name</strong> is <em>Sam</em>. I´m a web developer.",0,26));
$html = preg_replace("/\<\/?(body|html|p)>/", "", $dom->saveHTML());
echo $html;

应该给出输出： Hello, my **name**。

Answer 5

我对 Søren Løvborg printTruncated 函数进行了轻微更改，使其兼容 UTF-8：

   /* Truncate HTML, close opened tags
    *
    * @param int, maxlength of the string
    * @param string, html       
    * @return $html
    */  
    function html_truncate($maxLength, $html){

        mb_internal_encoding("UTF-8");

        $printedLength = 0;
        $position = 0;
        $tags = array();

        ob_start();

        while ($printedLength < $maxLength && preg_match('{</?([a-z]+)[^>]*>|&#?[a-zA-Z0-9]+;}', $html, $match, PREG_OFFSET_CAPTURE, $position)){

            list($tag, $tagPosition) = $match[0];

            // Print text leading up to the tag.
            $str = mb_strcut($html, $position, $tagPosition - $position);

            if ($printedLength + mb_strlen($str) > $maxLength){
                print(mb_strcut($str, 0, $maxLength - $printedLength));
                $printedLength = $maxLength;
                break;
            }

            print($str);
            $printedLength += mb_strlen($str);

            if ($tag[0] == '&'){
                // Handle the entity.
                print($tag);
                $printedLength++;
            }
            else{
                // Handle the tag.
                $tagName = $match[1][0];
                if ($tag[1] == '/'){
                    // This is a closing tag.

                    $openingTag = array_pop($tags);
                    assert($openingTag == $tagName); // check that tags are properly nested.

                    print($tag);
                }
                else if ($tag[mb_strlen($tag) - 2] == '/'){
                    // Self-closing tag.
                    print($tag);
                }
                else{
                    // Opening tag.
                    print($tag);
                    $tags[] = $tagName;
                }
            }

            // Continue after the tag.
            $position = $tagPosition + mb_strlen($tag);
        }

        // Print any remaining text.
        if ($printedLength < $maxLength && $position < mb_strlen($html))
            print(mb_strcut($html, $position, $maxLength - $printedLength));

        // Close any open tags.
        while (!empty($tags))
             printf('</%s>', array_pop($tags));


        $bufferOuput = ob_get_contents();

        ob_end_clean();         

        $html = $bufferOuput;   

        return $html;   

    }

Answer 6

您也可以使用 tidy ：

function truncate_html($html, $max_length) {   
  return tidy_repair_string(substr($html, 0, $max_length),
     array('wrap' => 0, 'show-body-only' => TRUE), 'utf8'); 
}

Answer 7

我使用了一个很好的函数 http:// /alanwhipple.com/2011/05/25/php-truncate-string-preserving-html-tags-words，显然取自 CakePHP

Answer 8

以下是一个简单的状态机解析器，它可以成功处理您的测试用例。 但我在嵌套标签上失败了，因为它不跟踪标签本身。 我还对 HTML 标签内的实体感到窒息（例如，在 标签的 href 属性中）。 因此它不能被认为是这个问题的 100% 解决方案，但因为它很容易理解，所以它可以成为更高级功能的基础。

function substr_html($string, $length)
{
    $count = 0;
    /*
     * $state = 0 - normal text
     * $state = 1 - in HTML tag
     * $state = 2 - in HTML entity
     */
    $state = 0;    
    for ($i = 0; $i < strlen($string); $i++) {
        $char = $string[$i];
        if ($char == '<') {
            $state = 1;
        } else if ($char == '&') {
            $state = 2;
            $count++;
        } else if ($char == ';') {
            $state = 0;
        } else if ($char == '>') {
            $state = 0;
        } else if ($state === 0) {
            $count++;
        }

        if ($count === $length) {
            return substr($string, 0, $i + 1);
        }
    }
    return $string;
}

Answer 9

100% 准确，但相当困难的方法：

1. 使用 DOM 迭代字符
2. 使用 DOM 方法删除剩余元素
3. 序列化 DOM

Easy 暴力方法：

1. 使用 preg_split('/()/') 和 PREG_DELIM_CAPTURE 将字符串拆分为标签（不是元素）和文本片段。
2. 测量您想要的文本长度（它将是分割后的每隔一个元素，您可以使用 html_entity_decode() 来帮助准确测量）
3. 剪切字符串（修剪 &[^\s;] +$ 位于末尾以消除可能被切碎的实体）
4. 使用 HTML Tidy 修复它

Answer 10

对 Søren Løvborg printTruncated 函数的另一项细微更改使其与 UTF-8（需要 mbstring）兼容，并使其返回字符串而不是打印字符串。 我认为它更有用。
我的代码没有像 Bounce 变体那样使用缓冲，只是多了一个变量。

UPD：要使其与标记属性中的 utf-8 字符正常工作，您需要 mb_preg_match 函数，如下所示。

非常感谢 Søren Løvborg 提供的这个功能，非常好。

/* Truncate HTML, close opened tags
*
* @param int, maxlength of the string
* @param string, html       
* @return $html
*/

function htmlTruncate($maxLength, $html)
{
    mb_internal_encoding("UTF-8");
    $printedLength = 0;
    $position = 0;
    $tags = array();
    $out = "";

    while ($printedLength < $maxLength && mb_preg_match('{</?([a-z]+)[^>]*>|&#?[a-zA-Z0-9]+;}', $html, $match, PREG_OFFSET_CAPTURE, $position))
    {
        list($tag, $tagPosition) = $match[0];

        // Print text leading up to the tag.
        $str = mb_substr($html, $position, $tagPosition - $position);
        if ($printedLength + mb_strlen($str) > $maxLength)
        {
            $out .= mb_substr($str, 0, $maxLength - $printedLength);
            $printedLength = $maxLength;
            break;
        }

        $out .= $str;
        $printedLength += mb_strlen($str);

        if ($tag[0] == '&')
        {
            // Handle the entity.
            $out .= $tag;
            $printedLength++;
        }
        else
        {
            // Handle the tag.
            $tagName = $match[1][0];
            if ($tag[1] == '/')
            {
                // This is a closing tag.

                $openingTag = array_pop($tags);
                assert($openingTag == $tagName); // check that tags are properly nested.

                $out .= $tag;
            }
            else if ($tag[mb_strlen($tag) - 2] == '/')
            {
                // Self-closing tag.
                $out .= $tag;
            }
            else
            {
                // Opening tag.
                $out .= $tag;
                $tags[] = $tagName;
            }
        }

        // Continue after the tag.
        $position = $tagPosition + mb_strlen($tag);
    }

    // Print any remaining text.
    if ($printedLength < $maxLength && $position < mb_strlen($html))
        $out .= mb_substr($html, $position, $maxLength - $printedLength);

    // Close any open tags.
    while (!empty($tags))
        $out .= sprintf('</%s>', array_pop($tags));

    return $out;
}

function mb_preg_match(
    $ps_pattern,
    $ps_subject,
    &$pa_matches,
    $pn_flags = 0,
    $pn_offset = 0,
    $ps_encoding = NULL
) {
    // WARNING! - All this function does is to correct offsets, nothing else:
    //(code is independent of PREG_PATTER_ORDER / PREG_SET_ORDER)

    if (is_null($ps_encoding)) $ps_encoding = mb_internal_encoding();

    $pn_offset = strlen(mb_substr($ps_subject, 0, $pn_offset, $ps_encoding));
    $ret = preg_match($ps_pattern, $ps_subject, $pa_matches, $pn_flags, $pn_offset);

    if ($ret && ($pn_flags & PREG_OFFSET_CAPTURE))
        foreach($pa_matches as &$ha_match) {
                $ha_match[1] = mb_strlen(substr($ps_subject, 0, $ha_match[1]), $ps_encoding);
        }

    return $ret;
}

Answer 11

使用以下函数 truncateHTML()：
https://github.com/jlgrall/truncateHTML

示例： 之后截断9 个字符（包括省略号）：

truncateHTML(9, "<p><b>A</b> red ball.</p>", ['wholeWord' => false]);
// =>           "<p><b>A</b> red ba…</p>"

功能： UTF-8、可配置省略号、包含/排除省略号长度、自闭合标签、折叠空格、不可见元素 (、

我编写了这个函数，因为我真的很喜欢 Søren Løvborg 的功能（特别是他如何管理编码），但我需要更多的功能和灵活性。

Answer 12

CakePHP 框架在适合我的文本助手中具有 HTML 感知的 truncate() 函数。 请参阅文本。 麻省理工学院许可证。 链接到源（由@Quentin提供）。

Answer 13

如果不使用验证器和解析器，这是非常困难的，原因是想象一下，如果您有

<div id='x'>
    <div id='y'>
        <h1>Heading</h1>
        500 
        lines 
        of 
        html
        ...
        etc
        ...
    </div>
</div>

计划如何截断它并最终得到有效的 HTML？

经过简短的搜索后，我发现 此链接 可以提供帮助。