Comment puis-je tronquer une chaîne après 20 mots en PHP?
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);
Les sorties:
Hello here is a long ...
Remplacez le nombre 3
par le nombre 20
ci-dessous pour obtenir les 20 premiers mots ou transmettez-le en tant que paramètre. Ce qui suit montre comment obtenir les 3 premiers mots: (modifiez donc le 3
en 20
pour modifier la valeur par défaut):
function first3words($s, $limit=3) {
return preg_replace('/((\w+\W*){'.($limit-1).'}(\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("")); # => ""
Se tronque à l'espace précédent le plus proche du caractère cible. Démo
$str
La chaîne à tronquer$chars
La quantité de caractères à supprimer, peut être remplacée par $to_space
$to_space
boolean
pour tronquer ou non de l'espace près de la limite $chars
Une fonction
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);
}
Échantillon
<?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");
?>
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--
Méthode truncate () simple et entièrement équipée:
function truncate($string, $width, $etc = ' ..')
{
$wrapped = explode('$trun$', wordwrap($string, $width, '$trun$', false), 2);
return $wrapped[0] . (isset($wrapped[1]) ? $etc : '');
}
utilisez explode () .
Exemple tiré de la documentation.
// Example 1
$pizza = "piece1 piece2 piece3 piece4 piece5 piece6";
$pieces = explode(" ", $pizza);
echo $pieces[0]; // piece1
echo $pieces[1]; // piece2
notez que exploser a une fonction limite. Pour que vous puissiez faire quelque chose comme
$message = implode(" ", explode(" ", $long_message, 20));
Essayez regex.
Vous avez besoin de quelque chose qui correspond à 20 mots (ou 20 limites de mots).
Donc (mon regex est terrible, corrigez-moi si ce n’est pas exact):
/(\w+\b){20}/
Et voici quelques exemples de regex en php .
Ce n'est pas ma propre création, c'est une modification des articles précédents. les crédits vont à 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;
}
Divisez la chaîne (dans un tableau) par <
space >
, puis prenez les 20 premiers éléments de ce tableau.
Un problème commun lors de la création dynamique Les pages Web (où le contenu provient d'une base de données, d'un système de gestion de contenu .__ ou d'une source externe telle qu'un flux RSS) correspondent à ce que le texte saisi peut être trop long et provoquer la mise en page casser'.
Une solution consiste à tronquer le texte afin qu'il tienne sur la page. Ce semble simple, mais souvent les résultats ne sont pas comme prévu en raison des mots et phrases coupées à points inappropriés.
Avec des points 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;
}
basé sur la réponse de 能量:
function truncate_words($string,$words=20) {
return preg_replace('/((\w+\W*){'.($words-1).'}(\w+))(.*)/', '${1}', $string);
}
ou
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;
}
}
Quelque chose comme ça pourrait probablement faire l'affaire:
<?php
$words = implode(' ', array_slice(split($input, ' ', 21), 0, 20));
utilisez PHP tokenizer function strtok () dans une boucle.
$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;
Essayez ci-dessous le code,
$text = implode(' ', array_slice(explode(' ', $text), 0, 32))
echo $text;
Cela m'a fonctionné pour UNICODE (UTF8) phrases aussi:
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;
}
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;
}
$aContent = explode(' ', $cContent);
$cContent = '';
$nCount = count($aContent);
for($nI = 0; ($nI < 20 && $nI < $nCount); $nI++) {
$cContent .= $aContent[$nI] . ' ';
}
trim($cContent, ' ');
echo '<p>' . $cContent . '</p>';
En voici un que j'utilise:
$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 );
Si vous codez sur Laravel juste use Illuminate\Support\Str
voici l'exemple
Str::words($category->publication->title, env('WORDS_COUNT_HOME'), '...')
J'espère que c'était utile.
Voici ce que j'ai implémenté.
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;
}
Comme vous pouvez le voir, il est basé sur la réponse de karim79, tout ce qui devait être changé était que l'instruction if devait également vérifier les mots et non les caractères.
J'ai également ajouté un lien vers la fonction principale pour plus de commodité. Jusqu'ici, il a fonctionné sans faille. Merci au fournisseur de solution d'origine.
Pour limiter les mots, utilise le petit code suivant:
$string = "hello world ! I love chocolate.";
$explode = array_slice(explode(' ', $string), 0, 4);
$implode = implode(" ",$explode);
echo $implode;
$ implot donnera: bonjour le monde! je
function limitText($string,$limit){
if(strlen($string) > $limit){
$string = substr($string, 0,$limit) . "...";
}
return $string;
}
cela retournera 20 mots. J'espère que cela aidera
Supposons que nous ayons les variables de chaîne $ string, $ start et $ limit, nous pouvons emprunter 3 ou 4 fonctions à PHP pour y parvenir. Elles sont:
et finalement, implode () pour joindre les éléments du tableau dans votre chaîne tronquée
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;
}
C'est si simple..
J'espère que cela a été utile.
J'ai fait ma fonction:
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;
}
$text='some text';
$len=strlen($text);
$limit=500;
// char
if($len>$limit){
$text=substr($text,0,$limit);
$words=explode(" ", $text);
$wcount=count($words);
$ll=strlen($words[$wcount]);
$text=substr($text,0,($limit-$ll+1)).'...';
}