Ich habe ein in PHP geschriebenes Code-Snippet, das einen Textblock aus einer Datenbank abruft und an ein Widget auf einer Webseite sendet. Der ursprüngliche Textblock kann ein langer Artikel oder ein oder zwei kurze Sätze sein. Für dieses Widget kann ich jedoch nicht mehr als beispielsweise 200 Zeichen anzeigen. Ich könnte substr () verwenden, um den Text mit 200 Zeichen abzuschneiden, aber das Ergebnis wäre, mitten in Wörtern abzuschneiden - was ich wirklich möchte, ist, den Text am Ende des letzten Wortes vor 200 Zeichen abzuschneiden.

Mit der Wordwrap- Funktion. Die Texte werden in mehrere Zeilen aufgeteilt, sodass die von Ihnen angegebene maximale Breite an den Wortgrenzen unterbrochen wird. Nach dem Teilen nehmen Sie einfach die erste Zeile:

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

Eine Sache, die dieser Oneliner nicht behandelt, ist der Fall, wenn der Text selbst kürzer als die gewünschte Breite ist. Um diesen Randfall zu behandeln, sollte man etwas tun wie:

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

Die obige Lösung hat das Problem, den Text vorzeitig zu schneiden, wenn er vor dem eigentlichen Schnittpunkt eine neue Zeile enthält. Hier eine Version, die dieses Problem löst:

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

Hier ist auch die PHPUnit-Testklasse, die zum Testen der Implementierung verwendet wird:

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:

Spezielle UTF8-Zeichen wie 'à' werden nicht behandelt. Fügen Sie 'u' am Ende des REGEX hinzu, um damit umzugehen:

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

Dies gibt die ersten 200 Zeichen von Wörtern zurück:

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

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

Und da haben Sie es - eine zuverlässige Methode, um eine Zeichenfolge auf das nächste ganze Wort zu kürzen und dabei die maximale Zeichenfolgenlänge zu unterschreiten.

Ich habe die anderen Beispiele oben ausprobiert und sie haben nicht die gewünschten Ergebnisse erzielt.

Die folgende Lösung wurde geboren, als ich einen $ break-Parameter der Wordwrap- Funktion bemerkte :

Zeichenfolge Zeilenumbruch (Zeichenfolge $ str [, int $ width = 75 [, Zeichenfolge $ break = "\ n" [, bool $ cut = false]])

Hier ist die Lösung :

/**
 * Truncates the given string at the specified length.
 *
 * @param string $str The input string.
 * @param int $width The number of chars at which the string will be truncated.
 * @return string
 */
function truncate($str, $width) {
    return strtok(wordwrap($str, $width, "...\n"), "\n");
}

Beispiel 1.

print truncate("This is very long string with many chars.", 25);

Das obige Beispiel gibt Folgendes aus:

This is very long string...

Beispiel 2.

print truncate("This is short string.", 25);

Das obige Beispiel gibt Folgendes aus:

This is short string.

Denken Sie daran, wann immer Sie irgendwo nach "Wörtern" teilen, dass einige Sprachen wie Chinesisch und Japanisch kein Leerzeichen zum Teilen von Wörtern verwenden. Außerdem kann ein böswilliger Benutzer einfach Text ohne Leerzeichen eingeben oder Unicode verwenden, das dem Standard-Leerzeichen ähnelt. In diesem Fall wird bei jeder von Ihnen verwendeten Lösung möglicherweise trotzdem der gesamte Text angezeigt. Eine Möglichkeit, dies zu umgehen, besteht darin, die Zeichenfolgenlänge zu überprüfen, nachdem sie wie gewohnt auf Leerzeichen aufgeteilt wurde. Wenn die Zeichenfolge immer noch über einem abnormalen Grenzwert liegt - in diesem Fall möglicherweise 225 Zeichen -, wird sie an diesem Grenzwert dumm aufgeteilt.

Noch eine Einschränkung bei solchen Dingen, wenn es um Nicht-ASCII-Zeichen geht. Strings, die sie enthalten, können von PHPs Standard strlen () als länger interpretiert werden, als sie tatsächlich sind, da ein einzelnes Zeichen zwei oder mehr Bytes anstelle von nur einem benötigen kann. Wenn Sie nur die Funktionen strlen () / substr () verwenden, um Zeichenfolgen zu teilen, können Sie eine Zeichenfolge in der Mitte eines Zeichens teilen! Im Zweifelsfall sind mb_strlen () / mb_substr () etwas narrensicherer.

Verwenden Sie strpos und substr:

<?php

$longString = "I have a code snippet written in PHP that pulls a block of text.";
$truncated = substr($longString,0,strpos($longString,' ',30));

echo $truncated;

Dadurch erhalten Sie eine Zeichenfolge, die nach 30 Zeichen am ersten Leerzeichen abgeschnitten wird.

Bitte schön:

function neat_trim($str, $n, $delim='…') {
   $len = strlen($str);
   if ($len > $n) {
       preg_match('/(.{' . $n . '}.*?)\b/', $str, $matches);
       return rtrim($matches[1]) . $delim;
   }
   else {
       return $str;
   }
}

Hier ist meine Funktion basierend auf dem Ansatz von @ Cd-MaN.

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

  return $string;
}

$shorttext = preg_replace('/^([\s\S]{1,200})[\s]+?[\s\S]+/', '$1', $fulltext);

Beschreibung:

• ^ - Beginnen Sie am Anfang der Zeichenfolge
• ([\s\S]{1,200}) - Holen Sie sich von 1 bis 200 eines beliebigen Charakters
• [\s]+?- Fügen Sie keine Leerzeichen am Ende des Kurztextes ein, damit wir word ...stattdessen vermeiden könnenword...
• [\s\S]+ - Alle anderen Inhalte abgleichen

Tests:

1. regex101.comLassen Sie uns zu oreinigen anderen hinzufügenr
2. regex101.com orrrr genau 200 Zeichen.
3. regex101.comnach dem fünften r orrrrrausgeschlossen.

Genießen.

Es ist überraschend, wie schwierig es ist, die perfekte Lösung für dieses Problem zu finden. Ich habe auf dieser Seite noch keine Antwort gefunden, die zumindest in einigen Situationen nicht fehlschlägt (insbesondere wenn die Zeichenfolge Zeilenumbrüche oder Tabulatoren enthält oder wenn der Wortumbruch etwas anderes als ein Leerzeichen ist oder wenn die Zeichenfolge UTF- enthält. 8 Multibyte-Zeichen).

Hier ist eine einfache Lösung, die in allen Fällen funktioniert. Hier gab es ähnliche Antworten, aber der Modifikator "s" ist wichtig, wenn Sie möchten, dass er mit mehrzeiligen Eingaben funktioniert, und der Modifikator "u" bewirkt, dass UTF-8-Multibyte-Zeichen korrekt ausgewertet werden.

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

Ein möglicher Randfall dabei ... Wenn die Zeichenfolge in den ersten $ characterCount-Zeichen überhaupt kein Leerzeichen enthält, wird die gesamte Zeichenfolge zurückgegeben. Wenn Sie es vorziehen, erzwingt eine Unterbrechung bei $ characterCount, auch wenn es sich nicht um eine Wortgrenze handelt, können Sie Folgendes verwenden:

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

Eine letzte Option, wenn Sie möchten, dass Ellipsen hinzugefügt werden, wenn die Zeichenfolge abgeschnitten wird ...

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

Ich würde die Funktion preg_match verwenden, um dies zu tun, da Sie einen ziemlich einfachen Ausdruck wünschen.

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

Der Ausdruck bedeutet "Passen Sie alle Teilzeichenfolgen an, die am Anfang der Länge 1-200 beginnen und mit einem Leerzeichen enden." Das Ergebnis ist in $ Ergebnis und die Übereinstimmung ist in $ Übereinstimmungen. Das kümmert sich um Ihre ursprüngliche Frage, die speziell auf jedem Platz endet. Wenn Sie möchten, dass es in Zeilenumbrüchen endet, ändern Sie den regulären Ausdruck in:

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

Ok, also habe ich eine andere Version davon basierend auf den obigen Antworten bekommen, aber mehr Dinge berücksichtigt (utf-8, \ n und & nbsp;), auch eine Zeile, die die WordPress-Shortcodes entfernt, die kommentiert werden, wenn sie mit wp verwendet werden.

function neatest_trim($content, $chars) 
  if (strlen($content) > $chars) 
  {
    $content = str_replace(' ', ' ', $content);
    $content = str_replace("\n", '', $content);
    // use with wordpress    
    //$content = strip_tags(strip_shortcodes(trim($content)));
    $content = strip_tags(trim($content));
    $content = preg_replace('/\s+?(\S+)?$/', '', mb_substr($content, 0, $chars));

    $content = trim($content) . '...';
    return $content;
  }

Dies ist eine kleine Lösung für die Antwort von mattmac:

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

Der einzige Unterschied besteht darin, am Ende von $ string ein Leerzeichen einzufügen. Dies stellt sicher, dass das letzte Wort nicht gemäß dem Kommentar von ReX357 abgeschnitten wird.

Ich habe nicht genügend Wiederholungspunkte, um dies als Kommentar hinzuzufügen.

/*
Cut the string without breaking any words, UTF-8 aware 
* param string $str The text string to split
* param integer $start The start position, defaults to 0
* param integer $words The number of words to extract, defaults to 15
*/
function wordCutString($str, $start = 0, $words = 15 ) {
    $arr = preg_split("/[\s]+/",  $str, $words+1);
    $arr = array_slice($arr, $start, $words);
    return join(' ', $arr);
}

Verwendung:

$input = 'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna liqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.';
echo wordCutString($input, 0, 10); 

Dies gibt die ersten 10 Wörter aus.

Das preg_split Funktion wird verwendet, um einen String in Teilzeichenfolgen aufzuteilen. Die Grenzen, entlang derer die Zeichenfolge geteilt werden soll, werden mithilfe eines Musters mit regulären Ausdrücken angegeben.

preg_split Die Funktion benötigt 4 Parameter, aber momentan sind nur die ersten 3 für uns relevant.

Erster Parameter - Muster Der erste Parameter ist das Muster für reguläre Ausdrücke, entlang dessen die Zeichenfolge aufgeteilt werden soll. In unserem Fall möchten wir die Zeichenfolge über Wortgrenzen hinweg aufteilen. Daher verwenden wir eine vordefinierte Zeichenklasse\s die Leerzeichen wie Leerzeichen, Tabulatoren, Wagenrücklauf und Zeilenvorschub entspricht.

Zweiter Parameter - Eingabezeichenfolge Der zweite Parameter ist die Langtextzeichenfolge, die wir teilen möchten.

Dritter Parameter - Limit Der dritte Parameter gibt die Anzahl der Teilzeichenfolgen an, die zurückgegeben werden sollen. Wenn Sie das Limit auf setzen n, gibt preg_split ein Array von n Elementen zurück. Die ersten n-1Elemente enthalten die Teilzeichenfolgen. Das letzte (n th)Element enthält den Rest der Zeichenfolge.

Basierend auf @Justin Polieys 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]. '...';
}

Ich habe eine Funktion, die fast das macht, was Sie wollen. Wenn Sie ein paar Änderungen vornehmen, passt sie genau:

<?php
function stripByWords($string,$length,$delimiter = '<br>') {
    $words_array = explode(" ",$string);
    $strlen = 0;
    $return = '';
    foreach($words_array as $word) {
        $strlen += mb_strlen($word,'utf8');
        $return .= $word." ";
        if($strlen >= $length) {
            $strlen = 0;
            $return .= $delimiter;
        }
    }
    return $return;
}
?>

So habe ich es gemacht:

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

Ich weiß, das ist alt, aber ...

function _truncate($str, $limit) {
    if(strlen($str) < $limit)
        return $str;
    $uid = uniqid();
    return array_shift(explode($uid, wordwrap($str, $limit, $uid)));
}

Ich erstelle eine Funktion, die substr ähnlicher ist, und verwende die Idee von @Dave.

function substr_full_word($str, $start, $end){
    $pos_ini = ($start == 0) ? $start : stripos(substr($str, $start, $end), ' ') + $start;
    if(strlen($str) > $end){ $pos_end = strrpos(substr($str, 0, ($end + 1)), ' '); } // IF STRING SIZE IS LESSER THAN END
    if(empty($pos_end)){ $pos_end = $end; } // FALLBACK
    return substr($str, $pos_ini, $pos_end);
}

Ps.: Der Schnitt in voller Länge kann kleiner als der Teil sein.

Dem Code von Dave und AmalMurali wurden IF / ELSEIF-Anweisungen hinzugefügt, um Zeichenfolgen ohne Leerzeichen zu behandeln

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

Ich finde das funktioniert:

Funktion abbreviate_string_to_whole_word ($ string, $ max_length, $ buffer) {

if (strlen($string)>$max_length) {
    $string_cropped=substr($string,0,$max_length-$buffer);
    $last_space=strrpos($string_cropped, " ");
    if ($last_space>0) {
        $string_cropped=substr($string_cropped,0,$last_space);
    }
    $abbreviated_string=$string_cropped." ...";
}
else {
    $abbreviated_string=$string;
}

return $abbreviated_string;

}}

Mit dem Puffer können Sie die Länge der zurückgegebenen Zeichenfolge anpassen.

Benutze das:

Der folgende Code entfernt ','. Wenn Sie ein anderes Zeichen oder eine andere Unterzeichenfolge haben, können Sie diese anstelle von ',' verwenden.

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

// wenn Sie ein anderes Zeichenfolgenkonto für haben

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

Obwohl dies eine ziemlich alte Frage ist, dachte ich, ich würde eine Alternative anbieten, da sie für PHP 4.3+ nicht erwähnt und gültig war.

Sie können die sprintfFunktionsfamilie verwenden, um Text mithilfe des %.ℕsGenauigkeitsmodifikators abzuschneiden.

Ein Punkt, .gefolgt von einer Ganzzahl, deren Bedeutung vom Spezifizierer abhängt:

• Für e-, E-, f- und F-Bezeichner: Dies ist die Anzahl der Stellen, die nach dem Dezimalpunkt gedruckt werden sollen (standardmäßig 6).
• Für g- und G-Spezifizierer: Dies ist die maximale Anzahl von signifikanten Ziffern, die gedruckt werden sollen.
• Für s-Bezeichner: Er fungiert als Grenzwert und legt eine maximale Zeichenbegrenzung für die Zeichenfolge fest

Einfache Kürzung https://3v4l.org/QJDJU

$string = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
var_dump(sprintf('%.10s', $string));

Ergebnis

string(10) "0123456789"

Erweiterte Kürzung https://3v4l.org/FCD21

Da sprintffunktioniert ähnlich substrund schneidet Wörter teilweise ab. Der folgende Ansatz stellt sicher, dass Wörter nicht durch Verwendung strpos(wordwrap(..., '[break]'), '[break]')eines speziellen Trennzeichens abgeschnitten werden. Dies ermöglicht es uns, die Position abzurufen und sicherzustellen, dass wir nicht mit Standard-Satzstrukturen übereinstimmen.

Rückgabe einer Zeichenfolge ohne teilweises Abschneiden von Wörtern, die die angegebene Breite nicht überschreitet, wobei bei Bedarf Zeilenumbrüche beibehalten werden.

function truncate($string, $width, $on = '[break]') {
    if (strlen($string) > $width && false !== ($p = strpos(wordwrap($string, $width, $on), $on))) {
        $string = sprintf('%.'. $p . 's', $string);
    }
    return $string;
}
var_dump(truncate('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ', 20));

var_dump(truncate("Lorem Ipsum is simply dummy text of the printing and typesetting industry.", 20));

var_dump(truncate("Lorem Ipsum\nis simply dummy text of the printing and typesetting industry.", 20));

Ergebnis

/* 
string(36) "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"  
string(14) "Lorem Ipsum is" 
string(14) "Lorem Ipsum
is" 
*/

Ergebnisse mit wordwrap($string, $width)oderstrtok(wordwrap($string, $width), "\n")

/*
string(14) "Lorem Ipsum is"
string(11) "Lorem Ipsum"
*/

Ich habe das schon mal benutzt

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

Hier können Sie dies versuchen

substr( $str, 0, strpos($str, ' ', 200) ); 

Ich glaube, das ist der einfachste Weg:

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

Ich benutze die Sonderzeichen, um den Text zu teilen und zu schneiden.

Vielleicht hilft das jemandem:

<?php

    $string = "Your line of text";
    $spl = preg_match("/([, \.\d\-''\"\"_()]*\w+[, \.\d\-''\"\"_()]*){50}/", $string, $matches);
    if (isset($matches[0])) {
        $matches[0] .= "...";
        echo "<br />" . $matches[0];
    } else {
        echo "<br />" . $string;
    }

?>