Mam fragment kodu napisany w języku PHP, który pobiera blok tekstu z bazy danych i wysyła go do widżetu na stronie internetowej. Oryginalnym blokiem tekstu może być długi artykuł lub krótkie zdanie lub dwa; ale dla tego widżetu nie mogę wyświetlić więcej niż, powiedzmy, 200 znaków. Mógłbym użyć substr (), aby odciąć tekst przy 200 znakach, ale rezultatem byłoby odcięcie w środku słów - tak naprawdę chcę, aby wyciąć tekst na końcu ostatniego słowa przed 200 znakami.

Korzystając z funkcji zawijania tekstu . Dzieli tekst na wiele wierszy, tak aby maksymalna szerokość była tą, którą określiłeś, zrywając na granicach słów. Po podzieleniu wystarczy wziąć pierwszą linię:

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

Jedną z rzeczy, których ten oneliner nie obsługuje, jest to, że sam tekst jest krótszy niż pożądana szerokość. Aby obsłużyć ten przypadek na krawędzi, należy zrobić coś takiego:

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

Powyższe rozwiązanie ma problem z przedwczesnym wycinaniem tekstu, jeśli zawiera on nową linię przed rzeczywistym punktem odcięcia. Oto wersja rozwiązująca ten problem:

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

Również tutaj jest klasa testowa PHPUnit używana do testowania implementacji:

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

EDYTOWAĆ :

Specjalne znaki UTF8, takie jak „à”, nie są obsługiwane. Dodaj „u” na końcu REGEXU, aby go obsłużyć:

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

Zwróci to pierwsze 200 znaków słów:

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

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

I oto masz - niezawodna metoda skracania dowolnego ciągu do najbliższego całego słowa, przy zachowaniu maksymalnej długości łańcucha.

Próbowałem innych przykładów powyżej i nie przyniosły one pożądanych rezultatów.

Poniższe rozwiązanie narodziło się, gdy zauważyłem parametr $ break funkcji zawijania słów :

ciąg wordwrap (ciąg $ str [, int $ szerokość = 75 [, ciąg $ break = "\ n" [, bool $ cut = false]]])

Oto rozwiązanie :

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

Przykład 1.

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

Powyższy przykład wyświetli:

This is very long string...

Przykład nr 2.

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

Powyższy przykład wyświetli:

This is short string.

Pamiętaj, ilekroć dzielisz słowo na słowo w dowolnym miejscu, w którym niektóre języki, takie jak chiński i japoński, nie używają spacji do dzielenia słów. Ponadto złośliwy użytkownik może po prostu wpisać tekst bez spacji lub użyć trochę podobnego do Unicode standardowego znaku spacji, w którym to przypadku każde zastosowane rozwiązanie może i tak wyświetlić cały tekst. Obejściem tego może być sprawdzenie długości łańcucha po normalnym podzieleniu go na spacje, a następnie, jeśli łańcuch jest nadal powyżej nienormalnego limitu - w tym przypadku może być to 225 znaków - idąc dalej i głupio dzieląc go na tym limicie.

Jeszcze jedno zastrzeżenie związane z takimi rzeczami, jeśli chodzi o znaki spoza ASCII; ciągi zawierające je mogą być interpretowane przez standardową strlen () PHP jako dłuższe niż są w rzeczywistości, ponieważ pojedynczy znak może zająć dwa lub więcej bajtów zamiast tylko jednego. Jeśli po prostu użyjesz funkcji strlen () / substr () do podzielenia ciągów, możesz podzielić ciąg w środku znaku! W razie wątpliwości mb_strlen () / mb_substr () są nieco bardziej niezawodne.

Użyj strpos i 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;

To da ci łańcuch obcięty na pierwszym miejscu po 30 znakach.

Proszę bardzo:

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

Oto moja funkcja oparta na podejściu @ 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);

Opis:

• ^ - zacznij od początku łańcucha
• ([\s\S]{1,200}) - zdobądź od 1 do 200 dowolnej postaci
• [\s]+?- nie dołączaj spacji na końcu krótkiego tekstu, abyśmy word ...zamiast tego mogli uniknąćword...
• [\s\S]+ - dopasuj wszystkie inne treści

Testy:

1. regex101.comdodajmy do orkilku innychr
2. regex101.com orrrr dokładnie 200 znaków.
3. regex101.compo piątym r orrrrrwykluczone.

Cieszyć się.

Zaskakujące jest, jak trudno jest znaleźć idealne rozwiązanie tego problemu. Nie znalazłem jeszcze odpowiedzi na tej stronie, która nie zawodzi, przynajmniej w niektórych sytuacjach (zwłaszcza jeśli ciąg znaków zawiera znaki nowej linii lub tabulatory, lub jeśli słowo przerwa jest czymś innym niż spacja, lub jeśli ciąg ma UTF- 8 znaków wielobajtowych).

Oto proste rozwiązanie, które działa we wszystkich przypadkach. Były tutaj podobne odpowiedzi, ale modyfikator „s” jest ważny, jeśli chcesz, aby działał z wejściem wieloliniowym, a modyfikator „u” sprawia, że ​​poprawnie ocenia znaki wielobajtowe UTF-8.

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

Jeden możliwy przypadek krawędzi z tym ... jeśli ciąg nie ma w ogóle żadnych białych znaków w pierwszych znakach $ characterCount, zwróci cały ciąg. Jeśli wolisz, że wymusza przerwanie na $ characterCount, nawet jeśli nie jest to granica słów, możesz użyć tego:

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

Ostatnia opcja, jeśli chcesz, aby dodała wielokropek, jeśli obcina ciąg ...

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

Użyłbym do tego funkcji preg_match, ponieważ to, czego chcesz, jest dość prostym wyrażeniem.

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

Wyrażenie oznacza „dopasuj dowolny podciąg zaczynający się od początku długości 1-200, kończący się spacją”. Wynik jest w $ wynik, a dopasowanie jest w $ dopasowaniach. To dotyczy twojego pierwotnego pytania, które kończy się na każdej przestrzeni. Jeśli chcesz, aby skończył się na nowej linii, zmień wyrażenie regularne na:

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

Ok, więc dostałem kolejną wersję tego opartą na powyższych odpowiedziach, ale biorąc pod uwagę więcej rzeczy (utf-8, \ n i & nbsp;), również wiersz usuwający skomentowane skróty wordpress, jeśli są używane z wp.

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

To jest mała poprawka dla odpowiedzi Mattmac:

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

Jedyną różnicą jest dodanie spacji na końcu ciągu $. Dzięki temu ostatnie słowo nie jest ucięte zgodnie z komentarzem ReX357.

Nie mam wystarczającej liczby punktów powtórzeń, aby dodać to jako komentarz.

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

Stosowanie:

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

Spowoduje to wyświetlenie pierwszych 10 słów.

preg_splitFunkcja służy do podzielić ciąg na podciągi. Granice, wzdłuż których ciąg ma zostać podzielony, są określone przy użyciu wzorca wyrażeń regularnych.

preg_split funkcja przyjmuje 4 parametry, ale tylko pierwsze 3 są teraz dla nas istotne.

Pierwszy parametr - wzorzec Pierwszy parametr to wzorzec wyrażeń regularnych, wzdłuż którego ma zostać podzielony ciąg. W naszym przypadku chcemy podzielić ciąg znaków na granice słów. Dlatego używamy predefiniowanej klasy znaków, \sktóra pasuje do białych znaków, takich jak spacja, tabulator, znak powrotu karetki i przesunięcie wiersza.

Drugi parametr - ciąg wejściowy Drugi parametr to długi ciąg tekstowy, który chcemy podzielić.

Trzeci parametr - limit Trzeci parametr określa liczbę podciągów, które powinny zostać zwrócone. Jeśli ustawisz limit na n, preg_split zwróci tablicę n elementów. Pierwsze n-1elementy będą zawierać podciągi. Ostatni (n th)element będzie zawierał resztę ciągu.

Na podstawie wyrażenia regularnego @Justin Poliey:

// 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]. '...';
}

Mam funkcję, która robi prawie wszystko, co chcesz, jeśli wykonasz kilka edycji, będzie pasować dokładnie:

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

Oto jak to zrobiłem:

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

Wiem, że to jest stare, ale ...

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

Tworzę funkcję bardziej podobną do substr i używając idei @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 .: Cięcie na całej długości może być mniejsze niż podłoże.

Dodano instrukcje IF / ELSEIF do kodu od Dave'a i AmalMurali do obsługi ciągów znaków bez spacji

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

Uważam, że działa:

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

}

Bufor pozwala dostosować długość zwracanego ciągu.

Użyj tego:

następujący kod usunie „,”. Jeśli masz inny znak lub podciąg, możesz użyć tego zamiast „,”

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

// jeśli masz inne konto string dla

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

Chociaż jest to dość stare pytanie, pomyślałem, że przedstawię alternatywę, ponieważ nie zostało to wspomniane i ważne dla PHP 4.3+.

Możesz użyć sprintfrodziny funkcji do obcięcia tekstu za pomocą %.ℕsmodyfikatora dokładności.

Kropka, .po której następuje liczba całkowita, której znaczenie zależy od specyfikatora:

• Dla specyfikatorów e, E, f i F: jest to liczba cyfr, które zostaną wydrukowane po przecinku (domyślnie jest to 6).
• Dla specyfikatorów gi G: jest to maksymalna liczba cyfr znaczących do wydrukowania.
• Dla specyfikatora s: działa jak punkt odcięcia, ustawiając maksymalny limit znaków dla łańcucha

Proste obcinanie https://3v4l.org/QJDJU

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

Wynik

string(10) "0123456789"

Rozszerzone obcinanie https://3v4l.org/FCD21

Ponieważ sprintfdziała podobnie substri częściowo odcina słowa. Poniższe podejście zapewni, że słowa nie zostaną odcięte przy użyciustrpos(wordwrap(..., '[break]'), '[break]') specjalnego separatora. To pozwala nam odzyskać pozycję i upewnić się, że nie pasujemy do standardowych struktur zdań.

Zwracanie ciągu bez częściowego odcinania słów, który nie przekracza określonej szerokości, z zachowaniem podziału linii w razie potrzeby.

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

Wynik

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

Wyniki za pomocą wordwrap($string, $width)lubstrtok(wordwrap($string, $width), "\n")

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

Użyłem tego wcześniej

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

Tutaj możesz spróbować

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

Uważam, że to najłatwiejszy sposób:

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

Używam znaków specjalnych do podziału tekstu i wycięcia go.

Może to pomoże komuś:

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

?>