Tronquer un texte contenant du code HTML, en ignorant les tags

En supposant que vous utilisez XHTML valide, c'est simple à analyser le code HTML et assurez-vous que les balises sont correctement gérés. Il vous suffit de suivre les balises ont été ouverts à ce jour, et assurez-vous de fermer à nouveau "sur votre moyen de sortir".

<?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");

Encodage note: Le code ci-dessus suppose que le XHTML est UTF-8 codé. Compatible ASCII codés sur un octet codages (comme Latin-1) sont également pris en charge, il suffit de passer false comme troisième argument. D'autres encodages multi-octets ne sont pas pris en charge, mais vous pouvez pirater le support en utilisant mb_convert_encoding pour convertir en UTF-8 avant l'appel de la fonction, puis de les convertir dans tous les print déclaration.

(Vous devriez toujours être en UTF-8, si.)

Modifier: mise à Jour pour gérer les entités de caractères et encodage UTF-8. Correction d'un bug où la fonction serait d'imprimer un caractère de trop, si ce caractère est un caractère de l'entité.

OriginalL'auteur Søren Løvborg

Précis à 100%, mais assez difficile d'approche:

1. Itérer charactes à l'aide de DOM
2. Utiliser les méthodes du DOM pour supprimer les éléments restants
3. Sérialiser les DOM

Simple force brute approche:

1. Scinde une chaîne en balises (pas d'éléments) et les fragments de texte à l'aide de preg_split('/(<tag>)/') avec PREG_DELIM_CAPTURE.
2. Mesure de la longueur du texte que vous voulez (ça va être chaque deuxième élément de split, vous pouvez utiliser html_entity_decode() pour aider à mesurer avec précision).
3. De couper la corde (trim &[^\s;]+$ à la fin pour se débarrasser de peut-être haché entité)
4. Fixer avec HTML Tidy

OriginalL'auteur Kornel

Ce qui suit est une simple machine d'état de l'analyseur qui s'occupe de vous de cas de test avec succès. J'échoue sur les balises imbriquées bien qu'il ne suit pas les balises elles-mêmes. J'ai aussi des bobines sur les entités à l'intérieur des balises HTML (par exemple dans un href-attribut d'un <a>-tag). Il ne peut donc pas être considéré comme un 100% solution à ce problème, mais parce que c'est facile à comprendre, il pourrait être la base pour une plus avancés de la fonction.

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

OriginalL'auteur Stefan Gehrig

J'ai fait de légères modifications à Søren Løvborg printTruncated fonction rendant compatible 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;   
}

OriginalL'auteur Bounce

Une autre lumière des changements de Søren Løvborg printTruncated fonction rendant UTF-8 (Besoins mbstring) compatible et de le rendre chaîne de retour de ne pas imprimer une. Je pense que c'est plus utile.
Et mon code ne pas utiliser de tampon comme Rebondir variante, juste une variable.

UPD: pour le faire fonctionner correctement avec l'encodage utf-8 caractères dans les attributs de la balise, vous devez mb_preg_match fonction, énumérés ci-dessous.

Un grand merci à Søren Løvborg pour cette fonction, il est très bon.

/* 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;
}

OriginalL'auteur Andrey Nagikh

La CakePHP cadre a un HTML-connaissance truncate() fonction dans le TextHelper qui fonctionne pour moi. Voir Core-Helpers/Texte. Licence MIT.

OriginalL'auteur DavidJ

Utiliser la fonction truncateHTML() à partir de:
https://github.com/jlgrall/truncateHTML

Exemple: tronquer après 9 caractères, y compris les points de suspension:

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

Caractéristiques: UTF-8, configurable points de suspension, d'inclure ou d'exclure de la longueur de points de suspension, fermeture automatique des balises, l'effondrement des espaces, des éléments invisibles (<head>, <script>, <noscript>, <style>, <!-- comments -->), HTML $entities;, tronquant au dernier mot en entier (avec l'option de toujours tronquer très long termes), PHP 5.6 et 7.0+, 240+ tests unitaires, retourne une chaîne de caractères (ne pas utiliser le tampon de sortie), et bien commenté code.

J'ai écrit cette fonction, parce que j'ai vraiment aimé Søren Løvborg's de la fonction ci-dessus (en particulier la façon dont il a géré les codages), mais j'ai besoin d'un peu plus de fonctionnalités et de flexibilité.

OriginalL'auteur jlgrall