42

我想截断一些文本（从数据库或文本文件加载），但它包含 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 实体&acute;- 必须将其视为单个字符（而不是本示例中的 7 个字符）。

strip_tags是一个后备，但我会丢失格式和链接，它仍然会有 HTML 实体的问题。

4

13 回答 13

50

假设您使用的是有效的 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>&lt;Hello&gt;</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>&#20;w\xC3\xB8rld!</em>"); print("\n");

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

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

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

于 2009-07-28T11:50:56.733 回答
5

我已经编写了一个函数，可以按照您的建议截断 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 = '&hellip;'){
            //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; 
        }
于 2012-03-06T18:30:31.863 回答
4

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

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

简单的蛮力方法：

  1. preg_split('/(<tag>)/')使用PREG_DELIM_CAPTURE将字符串拆分为标签（不是元素）和文本片段。
  2. 测量您想要的文本长度（它将是拆分的每隔一个元素，您可以html_entity_decode()用来帮助准确测量）
  3. 剪断绳子（&[^\s;]+$在末端修剪以去除可能被切碎的实体）
  4. 用 HTML Tidy 修复它
于 2009-07-28T12:04:36.987 回答
4

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

于 2012-01-12T19:43:47.650 回答
3

以下是一个简单的状态机解析器，可以成功处理您的测试用例。我在嵌套标签上失败了，因为它不跟踪标签本身。我还对 HTML 标记中的实体感到窒息（例如，在-tag的href-attribute 中）。<a>所以它不能被认为是这个问题的 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;
}
于 2009-07-28T12:01:35.793 回答
3

你也可以使用整洁：

function truncate_html($html, $max_length) {   
  return tidy_repair_string(substr($html, 0, $max_length),
     array('wrap' => 0, 'show-body-only' => TRUE), 'utf8'); 
}
于 2012-09-10T08:23:59.963 回答
2

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

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

应该给出输出：Hello, my <strong>**name**</strong>。

于 2009-07-28T12:41:00.787 回答
2

我对 Søren LøvborgprintTruncated函数进行了轻微更改，使其与 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;   

    }
于 2011-11-22T14:53:10.883 回答
2

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

  • 支持不成对的 HTML 标签（例如<hr>，<br> <col>等不要关闭 - 在 HTML 中，这些标签末尾不需要“/”（虽然是 XHTML）），
  • 可自定义的截断指示符（默认为&hellips;ie ... ），
  • 在不使用输出缓冲区的情况下作为字符串返回，并且
  • 100% 覆盖率的单元测试。

这一切都在Pastie。

于 2011-12-28T11:19:42.323 回答
2

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;
}
于 2012-01-15T09:34:42.723 回答
2

CakePHP框架的 Text Helper 中有一个可识别HTML 的 truncate() 函数，它适用于我。请参阅文本。麻省理工学院许可证。链接到源（由@Quentin 提供）。

于 2013-03-20T18:18:16.550 回答
2

使用truncateHTML()来自： https ://github.com/jlgrall/truncateHTML 的函数

示例：在 9 个字符后截断，包括省略号：

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

特点： UTF-8、可配置的省略号、包含/排除省略号的长度、自闭合标签、折叠空格、不可见元素（<head>、<script>、<noscript>、<style>、<!-- comments -->）、HTML $entities;、最后截断整个单词（可选择仍然截断很长的单词） ，PHP 5.6 和 7.0+，240+ 单元测试，返回一个字符串（不使用输出缓冲区），以及注释良好的代码。

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

于 2018-02-07T19:33:03.270 回答
0

如果不使用验证器和解析器，这很难做到，原因是想象一下，如果你有

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

你打算如何截断它并最终得到有效的 HTML？

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

于 2009-07-28T11:44:50.333 回答