Comment vérifier si une chaîne contient un mot spécifique en PHP ?

Fonctionnement de la fonction strpos()

La fonction strpos() prend deux paramètres :

1. $haystack : La chaîne dans laquelle effectuer la recherche.
2. $needle : La sous-chaîne à rechercher.

Elle renvoie un entier représentant l'index de la première occurrence de l'aiguille dans la botte de foin, ou false si l'aiguille n'est pas trouvée.

Il faut noter que strpos() effectue une recherche sensible à la casse. Cela signifie qu'elle tient compte des majuscules et des minuscules lors de la recherche de la sous-chaîne.

Voici un exemple d'utilisation de strpos() pour vérifier si une chaîne contient un mot :

$mot = "renard";
$phrase = "Le renard brun rapide saute par-dessus le chien paresseux";

// Teste si la chaîne contient le mot
if (strpos($phrase, $mot) !== false) {
    echo "Mot trouvé !";
} else {
    echo "Mot non trouvé !";
}

Dans ce code :

• Nous définissons la variable $mot comme la sous-chaîne que nous voulons rechercher, qui est "renard".
• Nous avons également la variable $phrase qui contient la phrase dans laquelle nous voulons rechercher le mot.
• Nous utilisons la fonction strpos() pour vérifier si $phrase contient $mot.
  • Si le mot est trouvé, strpos() renvoie l'index de sa première occurrence.
  • Si le mot n'est pas trouvé, strpos() renvoie false.
• La condition strpos($phrase, $mot) !== false vérifie si la valeur renvoyée n'est pas false.
  • Si le mot est trouvé, la condition est vraie, et le code dans le bloc if s'exécute, affichant "Mot trouvé !".
  • Si le mot n'est pas trouvé, le bloc else s'exécute, affichant "Mot non trouvé !".

$email = "utilisateur@exemple.com";
$domaine = "exemple.com";

if (strpos($email, $domaine) !== false) {
    echo "Domaine e-mail valide !";
} else {
    echo "Domaine e-mail invalide !";
}

Différences entre les fonctions strpos() et stripos()

PHP dispose également de la fonction stripos(), qui est similaire à strpos() mais effectue une recherche insensible à la casse. Cela signifie que stripos() ne tient pas compte des majuscules et des minuscules lors de la recherche de la sous-chaîne.

Vous utiliseriez strpos() lorsque vous avez besoin d'effectuer une recherche sensible à la casse et que vous voulez correspondre exactement à la casse de la sous-chaîne. Vous utiliseriez stripos() lorsque la casse de la sous-chaîne n'a pas d'importance et que vous voulez trouver la sous-chaîne quelle que soit sa casse.

Voici un exemple pour montrer la différence :

$mot = "Renard";
$phrase = "Le renard brun rapide saute par-dessus le chien paresseux";

if (strpos($phrase, $mot) !== false) {
    echo "Mot trouvé avec strpos() !";
} else {
    echo "Mot non trouvé avec strpos() !";
}

if (stripos($phrase, $mot) !== false) {
    echo "Mot trouvé avec stripos() !";
} else {
    echo "Mot non trouvé avec stripos() !";
}

Dans ce cas :

• strpos() renverrait "Mot non trouvé !" car elle effectue une recherche sensible à la casse et la sous-chaîne "Renard" (avec un R majuscule) n'existe pas dans la chaîne.
• stripos() renverrait "Mot trouvé !" car elle effectue une recherche insensible à la casse et trouve la sous-chaîne "renard" (avec un r minuscule) dans la chaîne.

Comparaison de strpos() avec d'autres fonctions de recherche de chaînes

PHP dispose d'autres fonctions pour rechercher dans des chaînes, telles que strstr(), stristr(), strrchr(), et strpbrk(). Voici une comparaison de ces fonctions :

$phrase = "Le renard brun rapide saute par-dessus le chien paresseux";

// Utilisation de strpos()
$position = strpos($phrase, "renard");
echo "Position de 'renard' avec strpos() : " . $position . "\n";

// Utilisation de strstr()
$sous_chaine = strstr($phrase, "brun");
echo "Sous-chaîne à partir de 'brun' avec strstr() : " . $sous_chaine . "\n";

// Utilisation de stristr()
$sous_chaine = stristr($phrase, "SAUTE");
echo "Sous-chaîne à partir de 'SAUTE' avec stristr() : " . $sous_chaine . "\n";

// Utilisation de strrchr()
$sous_chaine = strrchr($phrase, "e");
echo "Sous-chaîne à partir du dernier 'e' avec strrchr() : " . $sous_chaine . "\n";

// Utilisation de strpbrk()
$sous_chaine = strpbrk($phrase, "aeiou");
echo "Sous-chaîne à partir de la première voyelle avec strpbrk() : " . $sous_chaine . "\n";

Position de 'renard' avec strpos() : 3
Sous-chaîne à partir de 'brun' avec strstr() : brun rapide saute par-dessus le chien paresseux
Sous-chaîne à partir de 'SAUTE' avec stristr() : saute par-dessus le chien paresseux
Sous-chaîne à partir du dernier 'e' avec strrchr() : eux
Sous-chaîne à partir de la première voyelle avec strpbrk() : e renard brun rapide saute par-dessus le chien paresseux

Fonction str_contains()

La fonction str_contains() est une nouveauté de PHP 8 qui permet de vérifier si une chaîne contient une sous-chaîne. Elle renvoie une valeur booléenne indiquant si la sous-chaîne est trouvée dans la chaîne.

Cette fonction offre une façon plus simple d'effectuer cette tâche courante par rapport à l'utilisation de strpos() ou stripos(), qui nécessitent des vérifications supplémentaires sur la valeur renvoyée.

Syntaxe et utilisation de str_contains()

La fonction str_contains() a la syntaxe suivante :

str_contains(string $haystack, string $needle): bool

• $haystack : La chaîne dans laquelle effectuer la recherche.
• $needle : La sous-chaîne à rechercher.

La fonction renvoie true si $needle est trouvé dans $haystack, et false sinon.

Voici un exemple d'utilisation de str_contains() pour vérifier si une chaîne contient un mot spécifique :

$texte = "Le renard brun rapide saute par-dessus le chien paresseux";
$mot = "renard";

if (str_contains($texte, $mot)) {
    echo "Le mot '$mot' est trouvé dans le texte.";
} else {
    echo "Le mot '$mot' n'est pas trouvé dans le texte.";
}

Dans cet exemple, str_contains() vérifie si la chaîne $texte contient le mot $mot. Comme le mot "renard" est présent dans le texte, la fonction renvoie true, et le message "Le mot 'renard' est trouvé dans le texte." est affiché.

Avantages de l'utilisation de str_contains() par rapport aux autres méthodes

L'utilisation de str_contains() présente des avantages par rapport à d'autres méthodes comme strpos() et stripos() :

1. Meilleure lisibilité : Le nom de la fonction str_contains() indique clairement son but, rendant le code plus lisible. Elle élimine le besoin de vérifications supplémentaires sur la valeur renvoyée, car elle renvoie un booléen.

2. Simplicité : Avec str_contains(), vous pouvez vérifier si une chaîne contient une sous-chaîne en un seul appel de fonction. Vous n'avez pas besoin de comparer la valeur renvoyée avec false ou 0, comme c'est le cas avec strpos() et stripos().

3. Meilleures performances : La fonction str_contains() est conçue pour être performante et est généralement plus rapide que l'utilisation de strpos() ou stripos() dans la plupart des cas. Elle évite de renvoyer la position de la sous-chaîne, qui n'est pas nécessaire lorsque vous voulez simplement savoir si la sous-chaîne existe.

Utilisation de preg_match() pour vérifier si une chaîne contient un mot

La fonction preg_match() en PHP vous permet de vérifier si une chaîne correspond à un motif d'expression régulière. Vous pouvez l'utiliser pour vérifier si une chaîne contient un mot spécifique.

La fonction preg_match() a la syntaxe suivante :

preg_match(string $pattern, string $subject, array &$matches = null, int $flags = 0, int $offset = 0): int|false

• $pattern : Le motif d'expression régulière à faire correspondre.
• $subject : La chaîne à rechercher.
• $matches : (Optionnel) Un tableau à remplir avec les résultats de la recherche.
• $flags : (Optionnel) Des drapeaux pour modifier le comportement de la recherche.
• $offset : (Optionnel) Le décalage dans la chaîne où commencer la recherche.

La fonction renvoie le nombre de correspondances trouvées (0 ou 1), ou false en cas d'erreur.

Voici un exemple d'utilisation de preg_match() pour vérifier si une chaîne contient un mot :

$texte = "Le renard brun rapide saute par-dessus le chien paresseux";
$mot = "renard";
$motif = "/\b$mot\b/";

if (preg_match($motif, $texte)) {
    echo "Le mot '$mot' est trouvé dans la chaîne.";
} else {
    echo "Le mot '$mot' n'est pas trouvé dans la chaîne.";
}

Dans ce code :

• La variable $texte contient la chaîne à rechercher.
• La variable $mot contient le mot à rechercher.
• La variable $motif contient le motif d'expression régulière. Elle utilise l'ancre \b pour correspondre aux limites de mots, s'assurant que seuls les mots entiers sont correspondus (ainsi, "renard" ne correspondra pas à "renards").
• preg_match() vérifie si le $motif correspond au $texte.
  • Si une correspondance est trouvée, il renvoie 1, et le message "mot trouvé" est affiché.
  • Si aucune correspondance n'est trouvée, il renvoie 0, et le message "mot non trouvé" est affiché.

Vous pouvez également utiliser le paramètre $matches pour obtenir le texte correspondant :

if (preg_match($motif, $texte, $matches)) {
    echo "Texte correspondant : " . $matches[0];
}

Cela afficherait : "Texte correspondant : renard".

Avantages et inconvénients de l'utilisation des expressions régulières

Les expressions régulières présentent des avantages et des inconvénients lors de la vérification de la présence d'un mot dans une chaîne.

Avantages

• Flexibilité : Les regex peuvent correspondre à des motifs complexes, pas seulement à des mots spécifiques. Vous pouvez utiliser des classes de caractères, des ancres, des quantificateurs et plus encore pour définir des motifs précis.
• Puissance : Avec les regex, vous pouvez faire plus que simplement vérifier si une chaîne contient un mot. Vous pouvez extraire des parties de la chaîne, remplacer du texte, diviser la chaîne, et plus encore.

Inconvénients

• Complexité : La syntaxe des regex peut être difficile à lire et à écrire, surtout pour des motifs complexes. Cela peut rendre le code plus difficile à comprendre et à maintenir.
• Performance : Pour des recherches de texte simples, l'utilisation de regex peut être plus lente que l'utilisation de fonctions de chaînes comme strpos() ou str_contains(). Les regex doivent compiler le motif puis rechercher dans la chaîne, ce qui prend du temps.

Utilisation de la fonction strstr()

La fonction strstr() en PHP est une autre façon de vérifier si une chaîne contient un mot spécifique. Elle recherche la première occurrence d'une sous-chaîne dans une chaîne et renvoie le reste de la chaîne à partir de ce point.

La syntaxe de strstr() est la suivante :

strstr(string $haystack, string $needle, bool $before_needle = false): string|false

• $haystack : La chaîne dans laquelle effectuer la recherche.
• $needle : La sous-chaîne à rechercher.
• $before_needle : (Optionnel) Si défini à true, la fonction renvoie la partie de la chaîne avant la première occurrence de la sous-chaîne. Par défaut, c'est false.

Voici un exemple d'utilisation de strstr() pour vérifier si une chaîne contient un mot :

$texte = "Le renard brun rapide saute par-dessus le chien paresseux";
$mot = "renard";

if (strstr($texte, $mot)) {
    echo "Le mot '$mot' est trouvé dans la chaîne.";
} else {
    echo "Le mot '$mot' n'est pas trouvé dans la chaîne.";
}

Dans cet exemple, strstr() recherche le mot "renard" dans la chaîne $texte. Si le mot est trouvé, la fonction renvoie la sous-chaîne à partir de la première occurrence de "renard" jusqu'à la fin de la chaîne. La condition if (strstr($texte, $mot)) vérifie si la valeur renvoyée est vraie (non false), indiquant que le mot est trouvé.

$produits = [
    "Apple iPhone 12 Pro Max - 128 Go - Bleu Pacifique",
    "Samsung Galaxy S21 Ultra 5G - 256 Go - Noir Phantom",
    "Google Pixel 5 - 128 Go - Noir"
];

$motCle = "iPhone";

foreach ($produits as $produit) {
    if (strstr($produit, $motCle)) {
        echo "Le produit '$produit' contient le mot-clé '$motCle'.
";
    }
}

Le produit 'Apple iPhone 12 Pro Max - 128 Go - Bleu Pacifique' contient le mot-clé 'iPhone'.

Diviser la chaîne en un tableau avec explode()

Une autre approche pour vérifier si une chaîne contient un mot spécifique consiste à diviser la chaîne en un tableau de mots à l'aide de la fonction explode(), puis à vérifier si le mot existe dans le tableau.

La fonction explode() divise une chaîne en un tableau selon un délimiteur spécifié. Voici la syntaxe :

explode(string $separator, string $string, int $limit = PHP_INT_MAX): array

• $separator : Le délimiteur utilisé pour diviser la chaîne.
• $string : La chaîne à diviser.
• $limit : (Optionnel) Le nombremaximum d'éléments à renvoyer dans le tableau. Par défaut, c'est PHP_INT_MAX.

Voici un exemple d'utilisation de explode() pour vérifier si une chaîne contient un mot :

$texte = "Le renard brun rapide saute par-dessus le chien paresseux";
$mot = "renard";

$tableauMots = explode(" ", $texte);

if (in_array($mot, $tableauMots)) {
    echo "Le mot '$mot' est trouvé dans la chaîne.";
} else {
    echo "Le mot '$mot' n'est pas trouvé dans la chaîne.";
}

Dans ce code, explode(" ", $texte) divise la chaîne $texte en un tableau de mots en utilisant l'espace comme délimiteur. Le tableau résultant $tableauMots contient chaque mot de la chaîne comme un élément séparé.

La fonction in_array() est ensuite utilisée pour vérifier si le mot $mot existe dans le $tableauMots. Si le mot est trouvé, la fonction renvoie true, et le message correspondant est affiché.

$saisieUtilisateur = "apple, samsung, google";
$motsClés = explode(", ", $saisieUtilisateur);

// Recherche de produits contenant l'un des mots-clés
$produits = [
    "Apple iPhone 12 Pro Max - 128 Go - Bleu Pacifique",
    "Samsung Galaxy S21 Ultra 5G - 256 Go - Noir Phantom",
    "Google Pixel 5 - 128 Go - Noir"
];

foreach ($produits as $produit) {
    foreach ($motsClés as $motClé) {
        if (strstr($produit, $motClé)) {
            echo "Le produit '$produit' correspond au mot-clé '$motClé'.
";
        }
    }
}

Le produit 'Apple iPhone 12 Pro Max - 128 Go - Bleu Pacifique' correspond au mot-clé 'apple'.
Le produit 'Samsung Galaxy S21 Ultra 5G - 256 Go - Noir Phantom' correspond au mot-clé 'samsung'.
Le produit 'Google Pixel 5 - 128 Go - Noir' correspond au mot-clé 'google'.

Comparer la chaîne avec le mot en utilisant des opérateurs identiques

Vous pouvez également vérifier si une chaîne contient un mot spécifique en comparant directement la chaîne avec le mot à l'aide de l'opérateur identique ===.

Voici un exemple :

$texte = "renard";
$mot = "renard";

if ($texte === $mot) {
    echo "La chaîne est identique au mot '$mot'.";
} else {
    echo "La chaîne n'est pas identique au mot '$mot'.";
}

Dans ce cas, la chaîne $texte est directement comparée au mot $mot en utilisant l'opérateur ===. Si la chaîne et le mot sont identiques, la condition if ($texte === $mot) est évaluée à true, et le message correspondant est affiché.

Cependant, cette méthode a des limitations :

• Elle ne fonctionne que si la chaîne correspond exactement au mot. Si la chaîne contient des caractères supplémentaires ou si le mot est une sous-chaîne de la chaîne, la comparaison renverra false.
• Elle est sensible à la casse. Si la chaîne et le mot ont des casses différentes, la comparaison renverra false.

Par conséquent, cette méthode n'est adaptée que lorsque vous voulez vérifier si une chaîne est identique à un mot spécifique, plutôt que de vérifier si la chaîne contient le mot en tant que sous-chaîne.

$catégories = ["Électronique", "Vêtements", "Maison"];
$catégorieProduit = "Électronique";

if (in_array($catégorieProduit, $catégories, true)) {
    echo "La catégorie de produit '$catégorieProduit' est valide.";
} else {
    echo "La catégorie de produit '$catégorieProduit' n'est pas valide.";
}