Récupère les n premiers caractères d'une chaîne

Comment puis-je obtenir les n premiers caractères d'une chaîne en PHP? Quel est le moyen le plus rapide de couper une chaîne en un nombre spécifique de caractères et d'ajouter "..." si nécessaire?

//The simple version for 10 Characters from the beginning of the string
$string = substr($string,0,10).'...';

Mettre à jour:

Basé sur une suggestion pour vérifier la longueur (et également garantir des longueurs similaires sur les cordes coupées et non coupées):

$string = (strlen($string) > 13) ? substr($string,0,10).'...' : $string;

Vous obtiendrez donc une chaîne de 13 caractères maximum; soit 13 (ou moins) caractères normaux ou 10 caractères suivis de '...'

Mise à jour 2:

Ou comme fonction:

function truncate($string, $length, $dots = "...") {
    return (strlen($string) > $length) ? substr($string, 0, $length - strlen($dots)) . $dots : $string;
}

Mise à jour 3:

Cela fait un moment que j'ai écrit cette réponse et je n'utilise plus ce code. Je préfère cette fonction qui empêche de casser la chaîne au milieu d'un mot en utilisant la wordwrapfonction:

function truncate($string,$length=100,$append="…") {
  $string = trim($string);

  if(strlen($string) > $length) {
    $string = wordwrap($string, $length);
    $string = explode("\n", $string, 2);
    $string = $string[0] . $append;
  }

  return $string;
}

Cette fonctionnalité est intégrée à PHP depuis la version 4.0.6. Voir les documents .

echo mb_strimwidth('Hello World', 0, 10, '...');

// outputs Hello W...

Notez que les trimmarker(les points de suspension ci-dessus) sont inclus dans la longueur tronquée.

L'extension multi-octets peut être utile si vous avez besoin de contrôler le jeu de caractères de la chaîne.

$charset = 'UTF-8';
$length = 10;
$string = 'Hai to yoo! I like yoo soo!';
if(mb_strlen($string, $charset) > $length) {
  $string = mb_substr($string, 0, $length - 3, $charset) . '...';
}

parfois, vous devez limiter la chaîne au dernier mot complet, c'est-à-dire: vous ne voulez pas que le dernier mot soit rompu, vous vous arrêtez avec l'avant-dernier mot.

par exemple: nous devons limiter "This is my String" à 6 caractères mais au lieu de "This i ..." nous voulons qu'il soit "This ..." c'est-à-dire que nous ignorerons les lettres cassées dans le dernier mot.

ouf, je suis mal à expliquer, voici le code.

class Fun {

    public function limit_text($text, $len) {
        if (strlen($text) < $len) {
            return $text;
        }
        $text_words = explode(' ', $text);
        $out = null;


        foreach ($text_words as $word) {
            if ((strlen($word) > $len) && $out == null) {

                return substr($word, 0, $len) . "...";
            }
            if ((strlen($out) + strlen($word)) > $len) {
                return $out . "...";
            }
            $out.=" " . $word;
        }
        return $out;
    }

}

Si vous voulez couper en faisant attention à ne pas diviser les mots, vous pouvez faire ce qui suit

function ellipse($str,$n_chars,$crop_str=' [...]')
{
    $buff=strip_tags($str);
    if(strlen($buff) > $n_chars)
    {
        $cut_index=strpos($buff,' ',$n_chars);
        $buff=substr($buff,0,($cut_index===false? $n_chars: $cut_index+1)).$crop_str;
    }
    return $buff;
}

si $ str est plus court que $ n_chars, le retourne intact.

Si $ str est égal à $ n_chars, il le retourne tel quel également.

si $ str est plus long que $ n_chars, alors il recherche l'espace suivant à couper ou (s'il n'y a plus d'espace jusqu'à la fin) $ str est coupé grossièrement à la place à $ n_chars.

REMARQUE: sachez que cette méthode supprimera toutes les balises en cas de code HTML.

Le framework de codeigniter contient une aide pour cela, appelée "aide de texte". Voici une documentation du guide de l'utilisateur de codeigniter qui s'applique: http://codeigniter.com/user_guide/helpers/text_helper.html (il suffit de lire les sections word_limiter et character_limiter). Voici deux fonctions pertinentes pour votre question:

if ( ! function_exists('word_limiter'))
{
    function word_limiter($str, $limit = 100, $end_char = '…')
    {
        if (trim($str) == '')
        {
            return $str;
        }

        preg_match('/^\s*+(?:\S++\s*+){1,'.(int) $limit.'}/', $str, $matches);

        if (strlen($str) == strlen($matches[0]))
        {
            $end_char = '';
        }

        return rtrim($matches[0]).$end_char;
    }
}

Et

if ( ! function_exists('character_limiter'))
{
    function character_limiter($str, $n = 500, $end_char = '…')
    {
        if (strlen($str) < $n)
        {
            return $str;
        }

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

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

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

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

Utiliser une sous-chaîne

http://php.net/manual/en/function.substr.php

$foo = substr("abcde",0, 3) . "...";

if(strlen($text) > 10)
     $text = substr($text,0,10) . "...";

La fonction que j'ai utilisée:

function cutAfter($string, $len = 30, $append = '...') {
        return (strlen($string) > $len) ? 
          substr($string, 0, $len - strlen($append)) . $append : 
          $string;
}

Voyez-le en action .

C'est ce que je fais

    function cutat($num, $tt){
        if (mb_strlen($tt)>$num){
            $tt=mb_substr($tt,0,$num-2).'...';
        }
        return $tt;
    }

où $ num représente le nombre de caractères et $ tt la chaîne pour la manipulation.

J'ai développé une fonction pour cet usage

 function str_short($string,$limit)
        {
            $len=strlen($string);
            if($len>$limit)
            {
             $to_sub=$len-$limit;
             $crop_temp=substr($string,0,-$to_sub);
             return $crop_len=$crop_temp."...";
            }
            else
            {
                return $string;
            }
        }

vous appelez simplement la fonction avec chaîne et limite ,
par exemple: str_short("hahahahahah",5);
il coupera votre chaîne et ajoutera "..." à la fin
:)

Pour créer dans une fonction (pour une utilisation répétée) et une longueur limitée dynamique, utilisez:

function string_length_cutoff($string, $limit, $subtext = '...')
{
    return (strlen($string) > $limit) ? substr($string, 0, ($limit-strlen(subtext))).$subtext : $string;
}

// example usage:
echo string_length_cutoff('Michelle Lee Hammontree-Garcia', 26);

// or (for custom substitution text
echo string_length_cutoff('Michelle Lee Hammontree-Garcia', 26, '..');

Il est préférable de résumer votre code comme ceci (notez que la limite est facultative et par défaut à 10):

print limit($string);


function limit($var, $limit=10)
{
    if ( strlen($var) > $limit )
    {
        return substr($string, 0, $limit) . '...';
    }
    else
    {
        return $var;
    }
}

Je ne sais pas si c'est la solution la plus rapide, mais il semble que ce soit la plus courte:

$result = current(explode("\n", wordwrap($str, $width, "...\n")));

PS Voir quelques exemples ici https://stackoverflow.com/a/17852480/131337

substr () serait le meilleur, vous voudrez également vérifier la longueur de la chaîne en premier

$str = 'someLongString';
$max = 7;

if(strlen($str) > $max) {
   $str = substr($str, 0, $max) . '...';
}

WordWrap ne coupe pas la chaîne, il suffit de la diviser ...

$ width = 10;

$a = preg_replace ("~^(.{{$width}})(.+)~", '\\1…', $a);

ou avec un wordwrap

$a = preg_replace ("~^(.{1,${width}}\b)(.+)~", '\\1…', $a);

cette solution ne coupera pas les mots, elle ajoutera trois points après le premier espace. J'ai édité la solution @ Raccoon29 et j'ai remplacé toutes les fonctions par des fonctions mb_ afin que cela fonctionne pour toutes les langues comme l'arabe

function cut_string($str, $n_chars, $crop_str = '...') {
    $buff = strip_tags($str);
    if (mb_strlen($buff) > $n_chars) {
        $cut_index = mb_strpos($buff, ' ', $n_chars);
        $buff = mb_substr($buff, 0, ($cut_index === false ? $n_chars : $cut_index + 1), "UTF-8") . $crop_str;
    }
    return $buff;
}

$yourString = "bla blaaa bla blllla bla bla";
$out = "";
if(strlen($yourString) > 22) {
    while(strlen($yourString) > 22) {
        $pos = strrpos($yourString, " ");
        if($pos !== false && $pos <= 22) {
            $out = substr($yourString,0,$pos);
            break;
        } else {
            $yourString = substr($yourString,0,$pos);
            continue;
        }
    }
} else {
    $out = $yourString;
}
echo "Output String: ".$out;

S'il n'y a aucune exigence stricte sur la longueur de la chaîne tronquée, on peut l'utiliser pour tronquer et empêcher également de couper le dernier mot:

$text = "Knowledge is a natural right of every human being of which no one
has the right to deprive him or her under any pretext, except in a case where a
person does something which deprives him or her of that right. It is mere
stupidity to leave its benefits to certain individuals and teams who monopolize
these while the masses provide the facilities and pay the expenses for the
establishment of public sports.";

// we don't want new lines in our preview
$text_only_spaces = preg_replace('/\s+/', ' ', $text);

// truncates the text
$text_truncated = mb_substr($text_only_spaces, 0, mb_strpos($text_only_spaces, " ", 50));

// prevents last word truncation
$preview = trim(mb_substr($text_truncated, 0, mb_strrpos($text_truncated, " ")));

Dans ce cas, $previewsera "Knowledge is a natural right of every human being".

Exemple de code en direct: http://sandbox.onlinephpfunctions.com/code/25484a8b687d1f5ad93f62082b6379662a6b4713