Comment Tronquer une chaîne de caractères en PHP pour le terme le plus proche pour un certain nombre de caractères?

À l'aide de la wordwrap fonction. Il scinde les textes en lignes multiples, tels que la largeur maximale est celui que vous avez spécifié, la rupture aux limites des mots. Après la séparation, il vous suffit de prendre la première ligne:

substr($string, 0, strpos(wordwrap($string, $your_desired_width), "\n"));

Une chose de cette oneliner ne gère pas le cas où le texte lui-même est plus courte que la largeur désirée. Pour gérer ce bord-cas, on doit faire quelque chose comme:

if (strlen($string) > $your_desired_width) 
{
    $string = wordwrap($string, $your_desired_width);
    $string = substr($string, 0, strpos($string, "\n"));
}

---

La solution ci-dessus a le problème de l'prématurément de la coupe de la texte si elle contient un saut de ligne avant le cutpoint. Ici, une version qui permet de résoudre ce problème:

function tokenTruncate($string, $your_desired_width) {
  $parts = preg_split('/([\s\n\r]+)/', $string, null, PREG_SPLIT_DELIM_CAPTURE);
  $parts_count = count($parts);

  $length = 0;
  $last_part = 0;
  for (; $last_part < $parts_count; ++$last_part) {
    $length += strlen($parts[$last_part]);
    if ($length > $your_desired_width) { break; }
  }

  return implode(array_slice($parts, 0, $last_part));
}

Aussi, ici, est le PHPUnit testclass utilisé pour tester la mise en œuvre:

class TokenTruncateTest extends PHPUnit_Framework_TestCase {
  public function testBasic() {
    $this->assertEquals("1 3 5 7 9 ",
      tokenTruncate("1 3 5 7 9 11 14", 10));
  }

  public function testEmptyString() {
    $this->assertEquals("",
      tokenTruncate("", 10));
  }

  public function testShortString() {
    $this->assertEquals("1 3",
      tokenTruncate("1 3", 10));
  }

  public function testStringTooLong() {
    $this->assertEquals("",
      tokenTruncate("toooooooooooolooooong", 10));
  }

  public function testContainingNewline() {
    $this->assertEquals("1 3\n5 7 9 ",
      tokenTruncate("1 3\n5 7 9 11 14", 10));
  }
}

EDIT :

Spécial des caractères UTF8 comme 'à' ne sont pas traitées. Ajouter en " u " à la fin de la REGEX pour le manipuler:

$parts = preg_split('/([\s\n\r]+)/u', $string, null, PREG_SPLIT_DELIM_CAPTURE);

$WidgetText = substr($string, 0, strrpos(substr($string, 0, 200), ' '));

Et là vous l'avez — un moyen fiable de les tronquer une chaîne à l'entier le plus proche parole, tout en restant sous la longueur maximale de la chaîne.

J'ai essayé d'autres exemples ci-dessus et elles n'ont pas produit les résultats escomptés.

Garder à l'esprit chaque fois que vous êtes fractionnement par "mot" n'importe où que certaines langues, comme le Chinois et le Japonais n'utilisez pas un caractère d'espace pour fractionner les mots. Aussi, un utilisateur malveillant pourrait simplement saisir du texte sans espaces, ou à l'aide de certains Unicode qui se ressemblent à l'espace standard, auquel cas, toute solution que vous utilisez peut finir par afficher l'intégralité du texte, de toute façon. Un moyen de contourner cela peut être de vérifier la longueur de la corde après le fractionnement sur des espaces comme d'habitude, puis, si la chaîne est encore au-dessus une anomalie de la limite peut-être à 225 caractères dans ce cas - aller de l'avant et de le diviser dumbly à cette limite.

Encore une mise en garde avec ce genre de choses quand il s'agit de caractères non-ASCII; les chaînes contenant peut être interprété par PHP standard strlen() comme étant plus qu'ils ne le sont, parce qu'un seul caractère peut prendre deux ou plus de deux octets au lieu d'un seul. Si vous venez d'utiliser la strlen()/substr() des fonctions split chaînes, vous pouvez diviser une chaîne au milieu d'un personnage! En cas de doute, mb_strlen()/mb_substr() sont un peu plus infaillible.

Voici ma fonction sur la base d' @Cd-Homme approche.

function shorten($string, $width) {
  if(strlen($string) > $width) {
    $string = wordwrap($string, $width);
    $string = substr($string, 0, strpos($string, "\n"));
  }

  return $string;
}

Il est surprenant de constater combien il est difficile est de trouver la solution parfaite à ce problème. Je n'ai pas encore trouvé la réponse sur cette page qui n'a pas manqué, au moins dans certaines situations (en particulier si la chaîne contient des retours à la ligne ou des tabulations, ou si le mot rupture n'est rien d'autre qu'un espace, ou si la chaîne a de l'UTF-8 caractères multioctets).

Voici une solution simple qui fonctionne dans tous les cas. Il y avait le même genre de réponses ici, mais le "s" modificateur est important si vous voulez qu'il fonctionne avec multi-ligne d'entrée, et le "u" modificateur rend évaluer correctement l'UTF-8, les caractères multioctets.

function wholeWordTruncate($s, $characterCount) 
{
    if (preg_match("/^.{1,$characterCount}\b/su", $s, $match)) return $match[0];
    return $s;
}

Un possible cas de bord avec ce... si la chaîne n'a pas d'espaces dans la première tranche de characterCount caractères, il sera de retour l'ensemble de la chaîne. Si vous préférez, il force un saut à $characterCount même si elle n'est pas une limite de mot, vous pouvez utiliser ceci:

function wholeWordTruncate($s, $characterCount) 
{
    if (preg_match("/^.{1,$characterCount}\b/su", $s, $match)) return $match[0];
    return mb_substr($return, 0, $characterCount);
}

Une dernière option, si vous voulez l'avoir ajouter des points de suspension s'il tronque la chaîne...

function wholeWordTruncate($s, $characterCount, $addEllipsis = ' …') 
{
    $return = $s;
    if (preg_match("/^.{1,$characterCount}\b/su", $s, $match)) 
        $return = $match[0];
    else
        $return = mb_substr($return, 0, $characterCount);
    if (strlen($s) > strlen($return)) $return .= $addEllipsis;
    return $return;
}

Je voudrais utiliser la fonction preg_match pour ce faire, comme ce que vous voulez est assez simple expression.

$matches = array();
$result = preg_match("/^(.{1,199})[\s]/i", $text, $matches);

L'expression signifie "correspond à un sous-chaîne commençant à partir du début de la longueur de 1-200 qui se termine par un espace." Le résultat est dans $result, et le match est dans $matches. Qui prend soin de votre question initiale, qui est spécifiquement se terminant sur tout l'espace. Si vous souhaitez faire la fin sur les retours à la ligne, modifier l'expression régulière à:

$result = preg_match("/^(.{1,199})[\n]/i", $text, $matches);

C'est un petit correctif pour mattmac réponse:

preg_replace('/\s+?(\S+)?$/', '', substr($string . ' ', 0, 201));

La seule différence est d'ajouter un espace à la fin de $chaine. Cela garantit que le dernier mot n'est pas coupé comme par ReX357 commentaire.

Je n'ai pas assez de points de rep pour ajouter un commentaire.

Basé sur @Justin Poliey de la regex:

//Trim very long text to 120 characters. Add an ellipsis if the text is trimmed.
if(strlen($very_long_text) > 120) {
  $matches = array();
  preg_match("/^(.{1,120})[\s]/i", $very_long_text, $matches);
  $trimmed_text = $matches[0]. '...';
}

C'est la façon dont je l'ai fait:

$string = "I appreciate your service & idea to provide the branded toys at a fair rent price. This is really a wonderful to watch the kid not just playing with variety of toys but learning faster compare to the other kids who are not using the BooksandBeyond service. We wish you all the best";

print_r(substr($string, 0, strpos(wordwrap($string, 250), "\n")));

J'ai utilisé ce avant

<?php
    $your_desired_width = 200;
    $string = $var->content;
    if (strlen($string) > $your_desired_width) {
        $string = wordwrap($string, $your_desired_width);
        $string = substr($string, 0, strpos($string, "\n")) . " More...";
    }
    echo $string;
?>

Ajouté if/ELSEIF déclarations du code de Dave et AmalMurali pour la manipulation de chaînes de caractères sans espaces

if ((strpos($string, ' ') !== false) && (strlen($string) > 200)) { 
    $WidgetText = substr($string, 0, strrpos(substr($string, 0, 200), ' ')); 
} 
elseif (strlen($string) > 200) {
    $WidgetText = substr($string, 0, 200);
}

Utiliser ceci:

le code suivant supprime ','. Si vous avez n'importe quelle autre caractère ou une sous-chaîne de caractères, vous pouvez utiliser à la place de ','

substr($string, 0, strrpos(substr($string, 0, $comparingLength), ','))

//si vous avez une autre chaîne de compte pour

substr($string, 0, strrpos(substr($string, 0, $comparingLength-strlen($currentString)), ','))

Je crois que c'est la meilleure façon de le faire:

$lines = explode('♦♣♠',wordwrap($string, $length, '♦♣♠'));
$newstring = $lines[0] . ' • • •';

Je suis en utilisant les caractères spéciaux de scinder le texte et de le couper.