Quand j’ai commencé à enseigner le PHP à mes étudiants de BTS SIO, la manipulation de chaînes de caractères revenait systématiquement comme l’une des premières difficultés. Extraire un substring en PHP, c’est-à-dire récupérer une portion précise d’une chaîne, est pourtant une opération fondamentale que vous utiliserez dans presque tous vos projets. Que ce soit pour parser une URL, tronquer un texte d’aperçu ou valider un format de données, maîtriser l’extraction de sous-chaînes vous fera gagner un temps considérable.

Dans ce guide, je vous accompagne pas à pas à travers toutes les méthodes disponibles en PHP pour extraire un substring. Des bases avec substr() jusqu’aux approches modernes de PHP 8, vous aurez en main toutes les clés pour manipuler vos chaînes avec précision.

Qu’est-ce qu’un substring en PHP ?

Un substring (ou sous-chaîne) désigne une portion extraite d’une chaîne de caractères plus longue. Par exemple, dans la chaîne « Bonjour le monde », le mot « monde » est un substring. En PHP, plusieurs fonctions natives permettent d’effectuer cette extraction, la plus connue étant substr().

Pour bien comprendre le concept, il faut savoir que chaque caractère d’une chaîne PHP possède un index numérique commençant à 0. Ainsi, dans la chaîne « PHP », le « P » initial a l’index 0, le « H » a l’index 1 et le dernier « P » a l’index 2. C’est ce système d’indexation qui permet à PHP de savoir exactement où commencer et où terminer l’extraction.

Voici un exemple simple pour illustrer :

<?php
$chaine = "Bonjour le monde";

// Extraire "monde" (commence à l'index 11, longueur 5)
$substring = substr($chaine, 11, 5);
echo $substring; // Affiche : monde
?>

Cette logique d’indexation est commune à de nombreux langages de programmation. Si vous venez de JavaScript ou de Python, vous retrouverez des mécanismes similaires. La différence en PHP réside dans la richesse des fonctions dédiées aux chaînes, qui offrent une granularité fine pour chaque besoin. Pour approfondir les bases de la manipulation de chaînes, je vous recommande de consulter mon guide complet sur PHP Substring.

substr() : la fonction principale pour extraire une sous-chaîne

La fonction substr() est le couteau suisse de l’extraction de sous-chaînes en PHP. Sa syntaxe est claire et accepte trois paramètres :

substr(string $string, int $offset, ?int $length = null): string

• $string : la chaîne source dans laquelle extraire
• $offset : la position de départ (commence à 0)
• $length (optionnel) : le nombre de caractères à extraire

Voyons plusieurs cas d’utilisation courants :

<?php
$texte = "Développement web en PHP";

// Extraire à partir de l'index 15
echo substr($texte, 15);       // Affiche : en PHP

// Extraire 14 caractères depuis le début
echo substr($texte, 0, 14);    // Affiche : Développement

// Utiliser un offset négatif (depuis la fin)
echo substr($texte, -3);       // Affiche : PHP

// Combiner offset négatif et longueur
echo substr($texte, -6, 2);    // Affiche : en
?>

L’utilisation d’un offset négatif est particulièrement pratique quand vous connaissez la position par rapport à la fin de la chaîne plutôt que par rapport au début. C’est un pattern que j’utilise souvent pour extraire des extensions de fichiers :

<?php
$fichier = "rapport-2026.pdf";
$extension = substr($fichier, -3);
echo $extension; // Affiche : pdf
?>

Attention cependant : si l’offset dépasse la longueur de la chaîne, substr() retourne une chaîne vide en PHP 8+ (et false dans les versions antérieures). Pensez toujours à vérifier la longueur de votre chaîne avec strlen() avant d’extraire. Pour en savoir plus sur substr(), consultez mon article dédié à PHP substr.

mb_substr() : gérer les caractères spéciaux et UTF-8

Si vous travaillez avec du texte en français (ou toute langue utilisant des accents, des cédilles ou des caractères non-ASCII), substr() peut vous réserver de mauvaises surprises. La raison est simple : substr() travaille en octets, pas en caractères. Un « é » en UTF-8 occupe 2 octets, ce qui décale les positions.

<?php
$texte = "Éducation numérique";

// substr() compte en octets : résultat incorrect
echo substr($texte, 0, 9);    // Résultat tronqué ou illisible

// mb_substr() compte en caractères : résultat correct
echo mb_substr($texte, 0, 9); // Affiche : Éducation
?>

La fonction mb_substr() fait partie de l’extension mbstring (multibyte string) de PHP. Sa syntaxe est presque identique à substr(), avec un paramètre supplémentaire pour l’encodage :

mb_substr(string $string, int $start, ?int $length = null, ?string $encoding = null): string

En pratique, je recommande à tous mes étudiants d’utiliser systématiquement mb_substr() dès qu’il y a la moindre possibilité de rencontrer des caractères accentués. C’est une habitude qui évite des bugs difficiles à diagnostiquer en production. D’ailleurs, la documentation officielle PHP sur mb_substr précise que cette fonction est recommandée pour tout traitement de texte multilingue.

<?php
// Bonne pratique : toujours spécifier l'encodage
$prenom = "Héloïse";
$resultat = mb_substr($prenom, 0, 3, 'UTF-8');
echo $resultat; // Affiche : Hél

// Configurer l'encodage par défaut en début de script
mb_internal_encoding('UTF-8');
$resultat = mb_substr($prenom, 0, 3);
echo $resultat; // Affiche : Hél
?>

Pour vérifier que l’extension mbstring est activée sur votre serveur, utilisez phpinfo() ou la commande php -m | grep mbstring en ligne de commande. Sur la plupart des hébergements modernes, elle est activée par défaut.

Combiner strpos() et substr() pour extraire dynamiquement

Dans la réalité, vous ne connaissez pas toujours à l’avance la position exacte de ce que vous voulez extraire. C’est là que strpos() entre en jeu. Cette fonction localise la première occurrence d’une sous-chaîne et retourne sa position, que vous pouvez ensuite passer à substr().

<?php
$email = "[email protected]";

// Trouver la position du @
$position = strpos($email, '@');

if ($position !== false) {
    // Extraire le nom d'utilisateur (avant le @)
    $utilisateur = substr($email, 0, $position);
    echo $utilisateur; // Affiche : lucie.moreau

    // Extraire le domaine (après le @)
    $domaine = substr($email, $position + 1);
    echo $domaine; // Affiche : web-sio.fr
}
?>

Notez l’utilisation de !== false au lieu de != false. C’est crucial car strpos() peut retourner 0 (zéro) si la sous-chaîne se trouve au tout début, et en PHP, 0 == false est vrai. Cette subtilité piège régulièrement les débutants.

Voici un exemple plus avancé pour extraire une valeur d’un paramètre d’URL :

<?php
$url = "https://web-sio.fr/article?id=42&page=3";

// Extraire la valeur de l'id
$debut = strpos($url, 'id=');
if ($debut !== false) {
    $debut += 3; // Sauter "id="
    $fin = strpos($url, '&', $debut);

    if ($fin !== false) {
        $id = substr($url, $debut, $fin - $debut);
    } else {
        $id = substr($url, $debut);
    }
    echo $id; // Affiche : 42
}
?>

En production, je privilégie parse_url() et parse_str() pour le parsing d’URL, mais cet exemple illustre bien la mécanique strpos + substr. Cette combinaison reste très utile pour parser des formats personnalisés, des logs ou des fichiers CSV. Pour compléter vos connaissances sur les fonctions liées, pensez à consulter l’article sur empty() en PHP qui traite de la validation de valeurs extraites.

Alternatives modernes : str_contains, str_starts_with et explode

Depuis PHP 8.0, de nouvelles fonctions simplifient considérablement le travail avec les chaînes. Même si elles ne remplacent pas directement substr(), elles couvrent des cas d’usage où l’on utilisait auparavant des combinaisons substr + strpos.

str_contains() : vérifier la présence d’un substring

<?php
// Avant PHP 8 : lourd et piégeux
if (strpos($texte, 'PHP') !== false) {
    echo 'Trouvé';
}

// PHP 8+ : clair et lisible
if (str_contains($texte, 'PHP')) {
    echo 'Trouvé';
}
?>

str_starts_with() et str_ends_with()

<?php
$fichier = "rapport-final.pdf";

// Vérifier le début
if (str_starts_with($fichier, 'rapport')) {
    echo 'C\'est un rapport';
}

// Vérifier la fin (remplace substr($f, -3) === 'pdf')
if (str_ends_with($fichier, '.pdf')) {
    echo 'Fichier PDF détecté';
}
?>

explode() : découper une chaîne en tableau

La fonction explode() est une alternative puissante quand vous devez extraire des segments séparés par un délimiteur connu :

<?php
$date = "2026-07-06";
$parties = explode('-', $date);

$annee = $parties[0]; // 2026
$mois  = $parties[1]; // 07
$jour  = $parties[2]; // 06

// Avec list() pour plus de lisibilité
[$annee, $mois, $jour] = explode('-', $date);
echo "$jour/$mois/$annee"; // Affiche : 06/07/2026
?>

J’utilise explode() très fréquemment en cours, notamment pour le traitement de fichiers CSV ou la manipulation d’adresses IP. C’est souvent plus lisible qu’une série de substr() imbriqués. Pour aller plus loin dans la manipulation de données structurées, jetez un œil à mon guide sur PHP DateTime qui utilise aussi ces techniques de parsing.

L’opérateur ?: et la gestion des valeurs par défaut

Une question qui revient souvent chez mes étudiants : que fait l’opérateur ?: en PHP ? Il s’agit de l’opérateur ternaire raccourci, aussi appelé Elvis operator. Il permet d’attribuer une valeur par défaut quand une expression est évaluée comme « falsy ».

<?php
// Syntaxe ternaire complète
$resultat = ($valeur) ? $valeur : 'défaut';

// Syntaxe raccourcie avec ?:
$resultat = $valeur ?: 'défaut';

// Les deux lignes font exactement la même chose
?>

Dans le contexte de l’extraction de substrings, l’opérateur ?: est très utile pour gérer les cas où substr() retourne une chaîne vide ou une valeur inattendue :

<?php
$pseudo = "";

// Si le pseudo est vide, utiliser un défaut
$affichage = substr($pseudo, 0, 20) ?: 'Utilisateur anonyme';
echo $affichage; // Affiche : Utilisateur anonyme

// Combiné avec mb_substr pour un aperçu de texte
function apercu(string $texte, int $longueur = 100): string {
    $extrait = mb_substr($texte, 0, $longueur, 'UTF-8');
    return ($extrait !== $texte) ? $extrait . '...' : $texte;
}
?>

Depuis PHP 7.0, il existe aussi l’opérateur null coalescing ?? qui vérifie spécifiquement si la valeur est null (pas juste « falsy »). Choisissez ?: quand vous voulez un défaut pour toute valeur vide, et ?? quand vous ciblez spécifiquement null. La documentation PHP sur les opérateurs de comparaison détaille ces nuances avec précision.

Tableau comparatif des fonctions de manipulation de chaînes

Pour vous aider à choisir la bonne fonction selon votre besoin, voici un tableau récapitulatif que je distribue à mes étudiants en début de module :

Ce tableau couvre les fonctions que vous utiliserez dans 90 % des cas. Pour les scénarios avancés (expressions régulières, preg_match), la logique est différente mais le principe d’extraction reste le même.

Cas pratiques : exemples concrets d’extraction de substring

Passons à des exemples tirés de projets réels que j’ai supervisés en cours ou en entreprise. Ces cas pratiques vous montreront comment appliquer les fonctions vues précédemment dans des situations concrètes.

Tronquer un texte pour un aperçu d’article

<?php
function tronquer_texte(string $texte, int $max = 150): string {
    if (mb_strlen($texte, 'UTF-8') <= $max) {
        return $texte;
    }

    // Couper au dernier espace avant la limite
    $extrait = mb_substr($texte, 0, $max, 'UTF-8');
    $dernierEspace = mb_strrpos($extrait, ' ', 0, 'UTF-8');

    if ($dernierEspace !== false) {
        $extrait = mb_substr($extrait, 0, $dernierEspace, 'UTF-8');
    }

    return $extrait . '…';
}

$article = "PHP est un langage de programmation libre, principalement utilisé pour produire des pages web dynamiques via un serveur web.";
echo tronquer_texte($article, 60);
// Affiche : PHP est un langage de programmation libre,…
?>

Cette fonction est bien plus robuste qu’un simple substr($texte, 0, 150) . '...' car elle respecte les limites de mots et gère correctement les caractères accentués.

Extraire et valider un code postal français

<?php
function extraire_departement(string $codePostal): string {
    // Les départements corses : 2A et 2B
    if (str_starts_with($codePostal, '20')) {
        $commune = (int) substr($codePostal, 2);
        return ($commune < 200) ? '2A' : '2B';
    }

    // DOM-TOM : 3 premiers chiffres
    if ((int) substr($codePostal, 0, 2) >= 97) {
        return substr($codePostal, 0, 3);
    }

    // Métropole : 2 premiers chiffres
    return substr($codePostal, 0, 2);
}

echo extraire_departement('75001'); // 75
echo extraire_departement('97400'); // 974
echo extraire_departement('20137'); // 2A
?>

Parser un nom de fichier structuré

<?php
$fichier = "2026-07-06_facture_client-042.pdf";

// Extraire la date
$date = substr($fichier, 0, 10); // 2026-07-06

// Extraire le type de document
$sansDate = substr($fichier, 11);
$type = substr($sansDate, 0, strpos($sansDate, '_')); // facture

// Extraire le numéro client avec explode
$parties = explode('_', pathinfo($fichier, PATHINFO_FILENAME));
$client = end($parties); // client-042

echo "Date: $date, Type: $type, Client: $client";
?>

Ces exemples montrent que l’extraction de substrings ne se limite pas à des exercices académiques. C’est une compétence que vous mobiliserez au quotidien, que ce soit pour du traitement de données, de la validation de formulaires ou du parsing de fichiers. Pour d’autres techniques liées aux tableaux PHP, consultez l’article sur la longueur d’un tableau en PHP.

Comprendre str_word_count() pour le traitement de texte

La fonction str_word_count() est souvent méconnue mais très utile. Elle compte le nombre de mots dans une chaîne, et peut aussi renvoyer la liste des mots sous forme de tableau :

<?php
$phrase = "PHP est un langage puissant";

// Compter les mots
echo str_word_count($phrase); // Affiche : 5

// Obtenir un tableau indexé des mots
$mots = str_word_count($phrase, 1);
print_r($mots);
// Array ( [0] => PHP [1] => est [2] => un [3] => langage [4] => puissant )

// Obtenir les mots avec leur position dans la chaîne
$motsPositions = str_word_count($phrase, 2);
print_r($motsPositions);
// Array ( [0] => PHP [4] => est [8] => un [11] => langage [19] => puissant )
?>

Le paramètre format (0, 1 ou 2) change le type de retour. Avec 0 (par défaut), vous obtenez le nombre de mots. Avec 1, un tableau indexé. Avec 2, un tableau associatif où les clés sont les positions des mots. Cette fonction est très pratique pour limiter le nombre de mots d’un résumé ou pour créer un index de mots-clés.

Erreurs courantes et bonnes pratiques

Après des années d’enseignement et de code review, voici les erreurs que je retrouve le plus souvent chez les développeurs PHP, débutants comme confirmés.

Erreur n°1 : oublier que l’index commence à 0

<?php
$code = "ABCDEF";

// FAUX : on veut le 3e caractère, mais on obtient le 4e
$troisieme = substr($code, 3, 1); // D (pas C !)

// CORRECT
$troisieme = substr($code, 2, 1); // C
?>

Erreur n°2 : ne pas vérifier le retour de strpos()

<?php
$texte = "Bonjour";

// DANGEREUX : strpos retourne false si non trouvé
$pos = strpos($texte, 'xyz');
$resultat = substr($texte, $pos); // $pos vaut false, converti en 0 !

// CORRECT : toujours vérifier avec !==
if (($pos = strpos($texte, 'xyz')) !== false) {
    $resultat = substr($texte, $pos);
}
?>

Erreur n°3 : utiliser substr() sur du texte UTF-8

Je l’ai déjà mentionné mais c’est tellement fréquent que je le répète : utilisez mb_substr() dès que vous manipulez du texte susceptible de contenir des accents. En français, c’est quasiment systématique.

Bonnes pratiques à adopter

• Configurez mb_internal_encoding('UTF-8') en début de projet
• Préférez str_contains() à strpos() !== false si vous êtes en PHP 8+
• Utilisez explode() plutôt que des substr() en série quand le texte a un délimiteur régulier
• Validez toujours la longueur de la chaîne avant d’appliquer substr() avec un offset fixe
• Documentez les magic numbers : substr($code, 3) est moins clair que substr($code, strlen('FR-'))

Pour vous assurer que vos variables sont correctement initialisées avant extraction, mon article sur PHP empty vous sera très utile. Et si vous travaillez avec des requêtes SQL contenant des substrings, le SQL Cheat Sheet complète bien ce guide.

Lucie Moreau

Formatrice IT indépendante depuis 2016, ancienne étudiante BTS SIO SLAM. 6 ans d'expérience en entreprise.