str_replace - ¿Cómo puedo truncar una cadena a las primeras 20 palabras en PHP?

recorrer string php

Question

¿Cómo puedo truncar una cadena después de 20 palabras en PHP?

Answer 1

Al espacio más cercano

Trunca al espacio anterior más cercano al personaje objetivo. Demo

• $str La cadena que se truncará
• $chars La cantidad de caracteres que se van a $to_space , puede ser anulada por $to_space
• $to_space boolean para si truncar o no desde el espacio cerca del límite de $chars

Función

function truncateString($str, $chars, $to_space, $replacement="...") {
   if($chars > strlen($str)) return $str;

   $str = substr($str, 0, $chars);
   $space_pos = strrpos($str, " ");
   if($to_space && $space_pos >= 0) 
       $str = substr($str, 0, strrpos($str, " "));

   return($str . $replacement);
}

Muestra

<?php

$str = "this is a string that is just some text for you to test with";

print(truncateString($str, 20, false) . "/n");
print(truncateString($str, 22, false) . "/n");
print(truncateString($str, 24, true) . "/n");
print(truncateString($str, 26, true, " :)") . "/n");
print(truncateString($str, 28, true, "--") . "/n");

?>

Salida

this is a string tha...
this is a string that ...
this is a string that...
this is a string that is :)
this is a string that is--

Answer 2

Otra solución :)

$aContent = explode('' '', $cContent);
$cContent = '''';
$nCount = count($aContent);
for($nI = 0; ($nI < 20 && $nI < $nCount); $nI++) {
   $cContent .= $aContent[$nI] . '' '';
}
trim($cContent, '' '');
echo ''<p>'' . $cContent . ''</p>'';

Answer 3

Algo como esto probablemente podría hacer el truco:

<?php 
$words = implode('' '', array_slice(split($input, '' '', 21), 0, 20));

Answer 4

Aquí hay uno que uso:

    $truncate = function( $str, $length ) {
        if( strlen( $str ) > $length && false !== strpos( $str, '' '' ) ) {
            $str = preg_split( ''/ [^ ]*$/'', substr( $str, 0, $length ));
            return htmlspecialchars($str[0]) . ''…'';
        } else {
            return htmlspecialchars($str);
        }
    };
    return $truncate( $myStr, 50 );

Answer 5

Con puntos triples:

function limitWords($text, $limit) {
    $word_arr = explode(" ", $text);

    if (count($word_arr) > $limit) {
        $words = implode(" ", array_slice($word_arr , 0, $limit) ) . '' ...'';
        return $words;
    }

    return $text;
}

Answer 6

Divida la cadena (en una matriz) por < espacio > , y luego tome los primeros 20 elementos de esa matriz.

Answer 7

Esto es lo que he implementado.

function summaryMode($text, $limit, $link) {
    if (str_word_count($text, 0) > $limit) {
        $numwords = str_word_count($text, 2);
        $pos = array_keys($numwords);
        $text = substr($text, 0, $pos[$limit]).''... <a href="''.$link.''">Read More</a>'';
    }
    return $text;
}

Como puede ver, se basa en la respuesta de karim79, todo lo que necesitaba cambiar era que la declaración if también necesitaba verificar palabras y no caracteres.

También agregué un enlace a la función principal para mayor comodidad. Hasta ahora, ha funcionado perfectamente. Gracias al proveedor de soluciones original.

Answer 8

Esto también me funcionó para las oraciones UNICODE (UTF8) :

function myUTF8truncate($string, $width){
    if (mb_str_word_count($string) > $width) {
        $string= preg_replace(''/((/w+/W*|| [/p{L}]+/W*){''.($width-1).''}(/w+))(.*)/'', ''${1}'', $string);
    }
    return $string;
}

Answer 9

Hice mi función:

function summery($text, $limit) {
    $words=preg_split(''//s+/'', $text);
     $count=count(preg_split(''//s+/'', $text));
      if ($count > $limit) {
          $text=NULL;
          for($i=0;$i<$limit;$i++)
              $text.=$words[$i].'' '';
          $text.=''...'';
      }
      return $text;
    }

Answer 10

Método truncate () simple y completamente equipado:

function truncate($string, $width, $etc = '' ..'')
{
    $wrapped = explode(''$trun$'', wordwrap($string, $width, ''$trun$'', false), 2);
    return $wrapped[0] . (isset($wrapped[1]) ? $etc : '''');
}

Answer 11

No es mi propia creación, es una modificación de publicaciones anteriores. los créditos van a karim79.

function limit_text($text, $limit) {
    $strings = $text;
      if (strlen($text) > $limit) {
          $words = str_word_count($text, 2);
          $pos = array_keys($words);
          if(sizeof($pos) >$limit)
          {
            $text = substr($text, 0, $pos[$limit]) . ''...'';
          }
          return $text;
      }
      return $text;
    }

Answer 12

Para limitar palabras, estoy usando el siguiente pequeño código:

    $string = "hello world ! I love chocolate.";
    $explode = array_slice(explode('' '', $string), 0, 4);
    $implode = implode(" ",$explode);   
    echo $implode;

$ implot dará: ¡hola mundo! yo

Answer 13

Prueba regex.

Necesita algo que coincida con 20 palabras (o 20 límites de palabras).

Entonces (mi expresión regular es terrible, así que corrígeme si esto no es correcto):

/(/w+/b){20}/

Y aquí hay algunos ejemplos de expresiones regulares en php .

Answer 14

Pruebe el siguiente código,

 $text  = implode('' '', array_slice(explode('' '', $text), 0, 32))
 echo $text;

Answer 15

Supongamos que tenemos las variables de cadena $ string , $ start y $ limit , podemos pedir prestada 3 o 4 funciones de PHP para lograr esto. Son:

• función script_tags () PHP para eliminar las etiquetas HTML y PHP innecesarias (si las hay). Esto no será necesario, si no hay etiquetas HTML o PHP.
• explotar () para dividir $ string en una matriz
• array_splice () para especificar el número de palabras y de dónde empezará. Será controlado por valores asignados a nuestras variables $ start y $ limit .

• y finalmente, implode () para unir los elementos de la matriz a su cadena truncada.

  function truncateString($string, $start, $limit){
      $stripped_string =strip_tags($string); // if there are HTML or PHP tags
      $string_array =explode('' '',$stripped_string);
      $truncated_array = array_splice($string_array,$start,$limit);
      $truncated_string=implode('' '',$truncated_array);
  
      return $truncated_string;
  }

Es así de simple..

Espero que esto haya sido útil.

Answer 16

basado en la respuesta de 動靜 能量

function truncate_words($string,$words=20) {
 return preg_replace(''/((/w+/W*){''.($words-1).''}(/w+))(.*)/'', ''${1}'', $string);
}

o

function truncate_words_with_ellipsis($string,$words=20,$ellipsis='' ...'') {
 $new = preg_replace(''/((/w+/W*){''.($words-1).''}(/w+))(.*)/'', ''${1}'', $string);
 if($new != $string){
  return $new.$ellipsis;
 }else{
  return $string;
 }

}

Answer 17

cambie el número 2 al número 19 continuación para obtener las primeras 20 palabras. A continuación se muestra el uso de 2 para obtener las primeras 3 palabras: (así que cambie el 2 al 19 y le dará las primeras 20 palabras)

function first3words($s) {
    return preg_replace(''/((/w+/W*){2}(/w+))(.*)/'', ''${1}'', $s);    
}

var_dump(first3words("hello yes, world wah ha ha"));  # => "hello yes, world"
var_dump(first3words("hello yes,world wah ha ha"));   # => "hello yes,world"
var_dump(first3words("hello yes world wah ha ha"));   # => "hello yes world"
var_dump(first3words("hello yes world"));  # => "hello yes world"
var_dump(first3words("hello yes world.")); # => "hello yes world"
var_dump(first3words("hello yes"));  # => "hello yes"
var_dump(first3words("hello"));  # => "hello"
var_dump(first3words("a")); # => "a"
var_dump(first3words(""));  # => ""

Answer 18

qué pasa

chunk_split($str,20);

Entrada en el Manual de PHP

Answer 19

usa explode() .

Ejemplo de los documentos.

// Example 1
$pizza  = "piece1 piece2 piece3 piece4 piece5 piece6";
$pieces = explode(" ", $pizza);
echo $pieces[0]; // piece1
echo $pieces[1]; // piece2

tenga en cuenta que explotar tiene una función límite. Entonces podrías hacer algo como

$message = implode(" ", explode(" ", $long_message, 20));

Answer 20

usa la función de tokenizer de PHP strtok() en un bucle.

$token = strtok($string, " "); // we assume that words are separated by sapce or tab
$i = 0;
$first20Words = '''';
while ($token !== false && $i < 20) {
    $first20Words .= $token;
    $token = strtok(" ");
    $i++;
}
echo $first20Words;

Answer 21

Esto se ve bastante bien para mí :

Un problema común cuando se crean páginas web dinámicas (donde el contenido proviene de una base de datos, sistema de gestión de contenido o fuente externa, como una fuente RSS) es que el texto de entrada puede ser demasiado largo y hacer que el diseño de la página se "rompa".

Una solución es truncar el texto para que se ajuste a la página. Esto suena simple, pero a menudo los resultados no son los esperados debido a que las palabras y oraciones se cortan en puntos inapropiados.

Answer 22

function getShortString($string,$wordCount,$etc = true) 
{
     $expString = explode('' '',$string);
     $wordsInString = count($expString);
     if($wordsInString >= $wordCount )
     {
         $shortText = '''';
         for($i=0; $i < $wordCount-1; $i++)
         {
             $shortText .= $expString[$i].'' '';
         }
         return  $etc ? $shortText.=''...'' : $shortText; 
     }
     else return $string;
} 

Answer 23

function limitText($string){
        if(strlen($string) > 20){
                $string = substr($string, 0,20) . "...";
        }
        return $string;
}

esto devolverá 20 palabras y luego espero que ayude

Answer 24

function limit_text($text, $limit) {
      if (str_word_count($text, 0) > $limit) {
          $words = str_word_count($text, 2);
          $pos = array_keys($words);
          $text = substr($text, 0, $pos[$limit]) . ''...'';
      }
      return $text;
    }

echo limit_text(''Hello here is a long sentence blah blah blah blah blah hahahaha haha haaaaaa'', 5);

Productos:

Hello here is a long ...