Obtenga los primeros 100 caracteres de la cadena, respetando las palabras completas

Question

He hecho una pregunta similar aquí antes, pero necesito saber si este pequeño ajuste es posible. Quiero acortar una cadena a 100 caracteres y usar $small = substr($big, 0, 100); para hacerlo. Sin embargo, esto solo toma los primeros 100 caracteres y no le importa si divide una palabra o no.

¿Hay alguna manera de tomar los primeros 100 caracteres de una cadena, pero asegúrese de no romper una palabra?

Ejemplo:

$big = "This is a sentence that has more than 100 characters in it, and I want to return a string of only full words that is no more than 100 characters!" 

$small = some_function($big); 

$small = "This is a sentence that has more than 100 characters in it, and I want to return a string of only" 

¿Hay una manera de hacer esto usando PHP?

Answer 1

Todo lo que necesita hacer es usar:

$pos=strpos($content, ' ', 200); 
substr($content,0,$pos); 

Answer 2

Sí, la hay. Esta es una función que tomé prestada de un usuario en diferentes foros hace unos años, así que no me puedo atribuir el mérito.

//truncate a string only at a whitespace (by nogdog) 
function truncate($text, $length) { 
    $length = abs((int)$length); 
    if(strlen($text) > $length) { 
     $text = preg_replace("/^(.{1,$length})(\s.*|$)/s", '\\1...', $text); 
    } 
    return($text); 
} 

Nota que añade automáticamente elipses, si no quiere que sólo tiene que utilizar '\\1' como el segundo parámetro de la llamada preg_replace.

Answer 3

Si define palabras como "secuencias de caracteres delimitados por el espacio" ... Use strrpos() para buscar el último espacio de la cadena, acorte a esa posición, recorte el resultado.

Answer 4

Sure. La más sencilla es probablemente para escribir una envoltura alrededor de preg_match:

function limitString($string, $limit = 100) { 
    // Return early if the string is already shorter than the limit 
    if(strlen($string) < $limit) {return $string;} 

    $regex = "/(.{1,$limit})\b/"; 
    preg_match($regex, $string, $matches); 
    return $matches[1]; 
} 

EDIT: Actualizado al no incluir siempre un espacio como el último carácter de la cadena

Answer 5

Esto funciona muy bien para mí, lo uso en mi guión

<?PHP 
$big = "This is a sentence that has more than 100 characters in it, and I want to return a string of only full words that is no more than 100 characters!"; 
$small = some_function($big); 
echo $small; 

function some_function($string){ 
    $string = substr($string,0,100); 
    $string = substr($string,0,strrpos($string," ")); 
    return $string; 
} 
?> 

buena suerte

Answer 6

formatos WordWrap cadena de acuerdo con límite, ellos seprates con \ n por lo que tenemos líneas más pequeñas que 50, las ordenadas no están separadas explota cadena de sepratos según \ n por lo que tenemos una matriz correspondiente a las líneas la lista reúne el primer elemento.

list ($ short) = explode ("\ n", wordwrap ($ ali, 50));

por favor rep Evert, ya que no puedo comentar o rep.

aquí es muestra de la ejecución

php > $ali = "ali veli krbin yz doksan esikesiksld sjkas laksjald lksjd asldkjadlkajsdlakjlksjdlkaj aslkdj alkdjs akdljsalkdj "; 
php > list($short) = explode("\n",wordwrap($ali ,50)); 
php > var_dump($short); 
string(42) "ali veli krbin yz doksan esikesiksld sjkas" 
php > $ali =''; 
php > list($short) = explode("\n",wordwrap($ali ,50)); 
php > var_dump($short); 
string(0) "" 

Answer 7

Esta función acorta una cadena mediante la adición de "..." final de una palabra siempre que sea posible. La cadena devuelta tendrá una longitud máxima de $len incluyendo "...".

function truncate($str, $len) { 
    $tail = max(0, $len-10); 
    $trunk = substr($str, 0, $tail); 
    $trunk .= strrev(preg_replace('~^..+?[\s,:]\b|^...~', '...', strrev(substr($str, $tail, $len-$tail)))); 
    return $trunk; 
} 

Ejemplos salidas:

• truncate("Thanks for contributing an answer to Stack Overflow!", 15)
  devuelve "Thanks for..."
• truncate("To learn more, see our tips on writing great answers.", 15)
  rendimientos "To learn more..." (coma también truncados)
• truncate("Pseudopseudohypoparathyroidism", 15)
  devuelve "Pseudopseudo..."

Answer 8

aquí es fantástica solución con Dotts al final con palabras llenas

function text_cut($text, $length = 200, $dots = true) { 
    $text = trim(preg_replace('#[\s\n\r\t]{2,}#', ' ', $text)); 
    $text_temp = $text; 
    while (substr($text, $length, 1) != " ") { $length++; if ($length > strlen($text)) { break; } } 
    $text = substr($text, 0, $length); 
    return $text . (($dots == true && $text != '' && strlen($text_temp) > $length) ? '...' : ''); 
} 

de entrada: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

Salida: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut ... aliquip

Answer 9

Esto lo hizo por mí ...

//trim message to 100 characters, regardless of where it cuts off 
$msgTrimmed = mb_substr($var,0,100); 

//find the index of the last space in the trimmed message 
$lastSpace = strrpos($msgTrimmed, ' ', 0); 

//now trim the message at the last space so we don't cut it off in the middle of a word 
echo mb_substr($msgTrimmed,0,$lastSpace) 

Answer 10

aquí está mi solución:

/** 
* get_words_until() Returns a string of delimited text parts up to a certain length 
* If the "words" are too long to limit, it just slices em up to the limit with an ellipsis "..." 
* 
* @param $paragraph - The text you want to Parse 
* @param $limit - The maximum character length, e.g. 160 chars for SMS 
* @param string $delimiter - Use ' ' for words and '. ' for sentences (abbreviation bug) :) 
* @param null $ellipsis - Use '...' or ' (more)' - Still respects character limit 
* 
* @return string 
*/ 
function get_words_until($paragraph, $limit, $delimiter = ' ', $ellipsis = null) 
{ 
    $parts = explode($delimiter, $paragraph); 

    $preview = ""; 

    if ($ellipsis) { 
     $limit = $limit - strlen($ellipsis); 
    } 

    foreach ($parts as $part) { 
     $to_add = $part . $delimiter; 
     if (strlen($preview . trim($to_add)) <= $limit) { // Can the part fit? 
      $preview .= $to_add; 
      continue; 
     } 
     if (!strlen($preview)) { // Is preview blank? 
      $preview = substr($part, 0, $limit - 3) . '...'; // Forced ellipsis 
      break; 
     } 
    } 

    return trim($preview) . $ellipsis; 
} 

En su caso sería (ejemplo):

$big = "This is a sentence that has more than 100 characters in it, and I want to return a string of only full words that is no more than 100 characters!" 

$small = get_words_until($big, 100); 

Answer 11

Pido disculpas por resucitar esta pregunta, pero me encontré con este hilo y fou y un pequeño problema. Para cualquiera que desee un límite de caracteres que elimine las palabras que irían por encima de su límite dado, las respuestas anteriores funcionan muy bien. En mi caso específico, me gusta mostrar una palabra si el límite cae en el medio de dicha palabra. Decidí compartir mi solución en caso de que alguien más esté buscando esta funcionalidad y necesite incluir palabras en lugar de recortarlas.

function str_limit($str, $len = 100, $end = '...') 
{ 
    if(strlen($str) < $len) 
    { 
     return $str; 
    } 

    $str = preg_replace("/\s+/", ' ', str_replace(array("\r\n", "\r", "\n"), ' ', $str)); 

    if(strlen($str) <= $len) 
    { 
     return $str; 
    } 

    $out = ''; 
    foreach(explode(' ', trim($str)) as $val) 
    { 
     $out .= $val . ' '; 

     if(strlen($out) >= $len) 
     { 
      $out = trim($out); 
      return (strlen($out) == strlen($str)) ? $out : $out . $end; 
     } 
    } 
} 

Ejemplos:

• de entrada: echo str_limit('Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.', 100, '...');
• de salida: Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore...
• de entrada: echo str_limit('Lorem ipsum', 100, '...');
• de salida: Lorem ipsum
• de entrada: echo str_limit('Lorem ipsum', 1, '...');
• Salida: Lorem...

Answer 12

Aquí hay otra manera de hacerlo.

$big = "This is a sentence that has more than 100 characters in it, and I want to return a string of only full words that is no more than 100 characters!" 
$big = trim($big); 
$small = $big; 
       if(strlen($big) > 100){ 
       $small = mb_substr($small, 0, 100); 
       $last_position = mb_strripos($small, ' '); 
        if($last_position > 0){ 
        $small = mb_substr($small, 0, $last_position); 
        } 
       } 

      echo $small; 

O

echo (strlen($small) < strlen($big) ? $small.'...' : $small); 

Esto también es multibyte seguro y también funciona incluso si no hay espacios, en cuyo caso será simplemente volver primeros 100 caracteres. Toma los primeros 100 caracteres y luego busca desde el final hasta el delimitador de palabra más cercano.

Answer 13

function truncate ($str, $length) { 
    if (strlen($str) > $length) { 
     $str = substr($str, 0, $length+1); 
     $pos = strrpos($str, ' '); 
     $str = substr($str, 0, ($pos > 0)? $pos : $length); 
    } 
    return $str; 
} 

Ejemplo:

print truncate('The first step to eternal life is you have to die.', 25); 

string (25) "El primer paso para eterno"

print truncate('The first step to eternal life is you have to die.', 12); 

cadena (9) "El primero"

print truncate('FirstStepToEternalLife', 5); 

cadena (5) "En primer lugar"

Answer 14

El problema con la respuesta aceptada es que la cadena de resultado Balón por encima del límite, es decir, que puede superar los 100 caracteres desde strpos se verá después la offset y por lo tanto su longitud siempre será superior a su límite. Si la última palabra es larga, como squirreled, la duración de su resultado será 111 (para que tenga una idea).

Una mejor solución es utilizar la función wordwrap:

function truncate($str, $length = 125, $append = '...') { 
    if (strlen($str) > $length) { 
     $delim = "~\n~"; 
     $str = substr($str, 0, strpos(wordwrap($str, $length, $delim), $delim)) . $append; 
    } 

    return $str; 
} 


echo truncate("The quick brown fox jumped over the lazy dog.", 5); 

De esta manera usted puede estar seguro de la cadena se trunca debajo de su límite (y nunca pasa por encima)

P. S. Esto es particularmente útil si planea almacenar la cadena truncada en su base de datos con una columna fija-como VARCHAR (50), etc.

P.P.S. Tenga en cuenta el delimitador especial en wordwrap. Esto es para asegurarse de que su cadena esté truncada correctamente incluso cuando contenga líneas nuevas (de lo contrario, se truncará en la primera línea nueva que no desee).

Answer 15

Este es mi enfoque, basado en la respuesta de amir, pero no deja que ninguna palabra haga que la cadena sea más larga que el límite, usando strrpos() con un desplazamiento negativo.

Simple pero funciona. Estoy usando la misma sintaxis que en la función de ayuda de Strorlim() de Laravel, en caso de que quiera usarlo en un proyecto que no sea de Laravel.

function str_limit($value, $limit = 100, $end = '...') 
{ 
    $limit = $limit - mb_strlen($end); // Take into account $end string into the limit 
    $valuelen = mb_strlen($value); 
    return $limit < $valuelen ? mb_substr($value, 0, mb_strrpos($value, ' ', $limit - $valuelen)) . $end : $value; 
} 

Answer 16

¡Otra respuesta más! No estaba completamente satisfecho con otras respuestas, y quería un 'corte duro' (salto de palabra garantizado antes de $ max_characters, si es posible), así que ¡aquí está mi función para contribuir!

/** 
* Shortens a string (if necessary), trying for a non-word character before character limit, adds an ellipsis and 
* returns. Falls back to a forced cut if no non-word characters exist before. 
* 
* @param string $content 
* @param int $max_characters - number of characters to start looking for a space/break. 
* @param bool $add_ellipsis - add ellipsis if content is shortened 
* 
* @return string 
*/ 
public static function shorten($content, $max_characters = 100, $add_ellipsis = TRUE) { 
    if (strlen($content) <= $max_characters) { 
     return $content; 
    } 

    // search for non-word characters 
    $match_count = preg_match_all('/\W/', $content, $matches, PREG_OFFSET_CAPTURE); 

    // force a hard break if can't find another good solution 
    $pos = $max_characters; 

    if ($match_count > 0) { 
     foreach ($matches[0] as $match) { 
      // check if new position fits within 
      if ($match[1] <= $max_characters) { 
       $pos = $match[1]; 
      } else { 
       break; 
      } 
     } 
    } 

    $suffix = ($add_ellipsis) ? '&hellip;' : ''; 

    return substr($content, 0, $pos) . $suffix; 
} 

Answer 17

## obtener el primer carácter de una cadena ##

<?php 
    $content= $row->title; 
    $result = substr($content, 0, 70); 
    echo $result; 
    ?>