Comment vérifier si une chaîne contient un mot spécifique?
Considérer:
$a = 'How are you?';
if ($a contains 'are')
echo 'true';
Supposons que j'ai le code ci-dessus, quelle est la bonne façon d'écrire l'instruction if ($a contains 'are')?
Vous pouvez utiliser la fonction strpos() qui permet de rechercher l'occurrence d'une chaîne dans une autre:
$a = 'How are you?';
if (strpos($a, 'are') !== false) {
echo 'true';
}
Notez que l'utilisation de !== false est délibérée (ni != false ni === true ne fonctionneront); strpos() renvoie soit le décalage auquel la chaîne d'aiguille commence dans la chaîne de botte de foin, soit le booléen false si l'aiguille n'est pas trouvée. Puisque 0 est un décalage valide et que 0 est "falsey", nous ne pouvons pas utiliser de constructions plus simples comme !strpos($a, 'are').
Vous pouvez utiliser des expressions régulières, il vaut mieux pour la correspondance de mots que pour strpos comme mentionné par d'autres utilisateurs, il retournera également la valeur true pour des chaînes telles que tarif, soin, regard, etc. Ceci peut simplement être évité dans une expression régulière en utilisant Limites de mots.
Un match simple pour are pourrait ressembler à ceci:
_$a = 'How are you?';
if (preg_match('/\bare\b/', $a)) {
echo 'true';
}
_En ce qui concerne les performances, strpos est environ trois fois plus rapide et je pense qu’au bout d’un million de comparaisons simultanées, il fallait preg_match 1,5 seconde pour terminer et pour strpos cela a pris 0,5 seconde.
Edit: Afin de rechercher n’importe quelle partie de la chaîne, pas seulement Word par Word, je vous recommande d’utiliser une expression régulière telle que
_$a = 'How are you?';
$search = 'are y';
if(preg_match("/{$search}/i", $a)) {
echo 'true';
}
_La i à la fin de l'expression régulière modifie l'expression régulière pour qu'elle ne respecte pas la casse. Si vous ne le souhaitez pas, vous pouvez l'omettre.
Maintenant, cela peut être assez problématique dans certains cas, car la chaîne $ search n’est en aucun cas assainie, elle risque de ne pas être vérifiée dans certains cas, car si _$search_ est une entrée utilisateur, ils peuvent en ajouter. chaîne pouvant se comporter comme une expression régulière différente ...
En outre, voici un excellent outil pour tester et voir les explications de diverses expressions régulières Regex101
Pour combiner les deux ensembles de fonctionnalités en une seule fonction polyvalente (y compris avec une sensibilité à la casse sélectionnable), vous pouvez utiliser quelque chose comme ceci:
_function FindString($needle,$haystack,$i,$Word)
{ // $i should be "" or "i" for case insensitive
if (strtoupper($Word)=="W")
{ // if $Word is "W" then Word search instead of string in string search.
if (preg_match("/\b{$needle}\b/{$i}", $haystack))
{
return true;
}
}
else
{
if(preg_match("/{$needle}/{$i}", $haystack))
{
return true;
}
}
return false;
// Put quotes around true and false above to return them as strings instead of as bools/ints.
}
_Voici une petite fonction d’utilité utile dans des situations comme celle-ci.
// returns true if $needle is a substring of $haystack
function contains($needle, $haystack)
{
return strpos($haystack, $needle) !== false;
}
Bien que la plupart de ces réponses vous indiquent si une sous-chaîne apparaît dans votre chaîne, ce n'est généralement pas ce que vous voulez si vous recherchez un mot particulier , et non une sous-chaîne .
Quelle est la différence? Les sous-chaînes peuvent apparaître dans d'autres mots:
- Les "sont" au début de "zone"
- Les "sont" à la fin du "lièvre"
- Les "sont" au milieu des "tarifs"
Une façon d’y remédier consiste à utiliser une expression régulière associée à limites de mot (\b):
function containsWord($str, $Word)
{
return !!preg_match('#\\b' . preg_quote($Word, '#') . '\\b#i', $str);
}
Cette méthode n'a pas les mêmes faux positifs notés ci-dessus, mais elle a ses propres cas Edge. Les limites de mot correspondent aux caractères non-Word (\W), qui vont être tout ce qui n'est pas a-z, A-Z, 0-9 ou _ . Cela signifie que les chiffres et les traits de soulignement seront considérés comme des caractères Word et que les scénarios comme celui-ci échoueront:
- Les "sont" dans "Qu'est-ce que vous pensez?"
- Les "sont" dans "lol u dunno wut ceux qui sont4?"
Si vous voulez quelque chose de plus précis que cela, vous devrez commencer à analyser la syntaxe en anglais, ce qui est une assez grosse boîte de vers (et suppose une utilisation correcte de la syntaxe, de toute façon, ce qui n'est pas toujours évident).
Pour déterminer si une chaîne contient une autre chaîne, vous pouvez utiliser la fonction PHP strpos () .
int strpos ( string $haystack , mixed $needle [, int $offset = 0 ] )
<?php
$haystack = 'how are you';
$needle = 'are';
if (strpos($haystack,$needle) !== false) {
echo "$haystack contains $needle";
}
?>
ATTENTION:
Si l'aiguille que vous recherchez se trouve au début de la botte de foin, elle retournera la position 0; si vous effectuez une comparaison == qui ne fonctionnera pas, vous devrez effectuer un ===.
Un signe == est une comparaison et vérifie si la variable/expression/constante à gauche a la même valeur que la variable/expression/constante à droite.
Un signe === est une comparaison permettant de voir si deux variables/expressions/constantes sont égales AND ont le même type - c’est-à-dire que les deux sont des chaînes ou que les deux sont des entiers.
<?php
$mystring = 'abc';
$findme = 'a';
$pos = strpos($mystring, $findme);
// Note our use of ===. Simply, == would not work as expected
// because the position of 'a' was the 0th (first) character.
if ($pos === false) {
echo "The string '$findme' was not found in the string '$mystring'.";
}
else {
echo "The string '$findme' was found in the string '$mystring',";
echo " and exists at position $pos.";
}
?>
Observez les commentaires de SamGoody et de Lego Stormtroopr.
Si vous recherchez un algorithme PHP pour classer les résultats de recherche en fonction de la proximité/pertinence de plusieurs mots, voici un rapide et facile moyen de générer des résultats de recherche avec PHP uniquement:
Problèmes avec les autres méthodes de recherche booléennes telles que strpos(), preg_match(), strstr() ou stristr()
- ne peut pas rechercher plusieurs mots
- les résultats ne sont pas classés
Méthode PHP basée sur modèle d'espace vectoriel et tf-idf (fréquence du document – fréquence du document inverse)):
Cela semble difficile mais étonnamment facile.
Si nous voulons rechercher plusieurs mots dans une chaîne, le problème principal est de savoir comment attribuer un poids à chacun d'entre eux.
Si nous pouvions pondérer les termes dans une chaîne en fonction de leur représentativité de la chaîne dans son ensemble, nous pourrions classer nos résultats en fonction de ceux qui correspondent le mieux à la requête.
C’est l’idée du modèle d’espace vectoriel pas très éloigné du fonctionnement de la recherche de texte intégral SQL:
function get_corpus_index($corpus = array(), $separator=' ') {
$dictionary = array();
$doc_count = array();
foreach($corpus as $doc_id => $doc) {
$terms = explode($separator, $doc);
$doc_count[$doc_id] = count($terms);
// tf–idf, short for term frequency–inverse document frequency,
// according to wikipedia is a numerical statistic that is intended to reflect
// how important a Word is to a document in a corpus
foreach($terms as $term) {
if(!isset($dictionary[$term])) {
$dictionary[$term] = array('document_frequency' => 0, 'postings' => array());
}
if(!isset($dictionary[$term]['postings'][$doc_id])) {
$dictionary[$term]['document_frequency']++;
$dictionary[$term]['postings'][$doc_id] = array('term_frequency' => 0);
}
$dictionary[$term]['postings'][$doc_id]['term_frequency']++;
}
//from http://phpir.com/simple-search-the-vector-space-model/
}
return array('doc_count' => $doc_count, 'dictionary' => $dictionary);
}
function get_similar_documents($query='', $corpus=array(), $separator=' '){
$similar_documents=array();
if($query!=''&&!empty($corpus)){
$words=explode($separator,$query);
$corpus=get_corpus_index($corpus, $separator);
$doc_count=count($corpus['doc_count']);
foreach($words as $Word) {
if(isset($corpus['dictionary'][$Word])){
$entry = $corpus['dictionary'][$Word];
foreach($entry['postings'] as $doc_id => $posting) {
//get term frequency–inverse document frequency
$score=$posting['term_frequency'] * log($doc_count + 1 / $entry['document_frequency'] + 1, 2);
if(isset($similar_documents[$doc_id])){
$similar_documents[$doc_id]+=$score;
}
else{
$similar_documents[$doc_id]=$score;
}
}
}
}
// length normalise
foreach($similar_documents as $doc_id => $score) {
$similar_documents[$doc_id] = $score/$corpus['doc_count'][$doc_id];
}
// sort from high to low
arsort($similar_documents);
}
return $similar_documents;
}
CAS 1
$query = 'are';
$corpus = array(
1 => 'How are you?',
);
$match_results=get_similar_documents($query,$corpus);
echo '<pre>';
print_r($match_results);
echo '</pre>';
RÉSULTAT
Array
(
[1] => 0.52832083357372
)
CAS 2
$query = 'are';
$corpus = array(
1 => 'how are you today?',
2 => 'how do you do',
3 => 'here you are! how are you? Are we done yet?'
);
$match_results=get_similar_documents($query,$corpus);
echo '<pre>';
print_r($match_results);
echo '</pre>';
RÉSULTATS
Array
(
[1] => 0.54248125036058
[3] => 0.21699250014423
)
CAS 3
$query = 'we are done';
$corpus = array(
1 => 'how are you today?',
2 => 'how do you do',
3 => 'here you are! how are you? Are we done yet?'
);
$match_results=get_similar_documents($query,$corpus);
echo '<pre>';
print_r($match_results);
echo '</pre>';
RÉSULTATS
Array
(
[3] => 0.6813781191217
[1] => 0.54248125036058
)
Il y a beaucoup d'améliorations à apporter, mais le modèle fournit un moyen d'obtenir de bons résultats à partir de requêtes naturelles, qui n'ont pas d'opérateurs booléens tels que strpos(), preg_match(), strstr() ou stristr().
NOTA BENE
Éliminer éventuellement la redondance avant de rechercher les mots
réduisant ainsi la taille de l'index et entraînant moins de besoins en stockage
moins d'E/S de disque
indexation plus rapide et par conséquent une recherche plus rapide.
1. Normalisation
- Convertir tout le texte en minuscule
2. Élimination des mots vides
- Éliminer les mots du texte qui n'ont pas de véritable sens (comme 'et', 'ou', 'le', 'pour', etc.)
3. Substitution de dictionnaire
Remplacez les mots par d'autres qui ont une signification identique ou similaire. (ex: remplacer les exemples de 'affamé' et 'affamé' par 'la faim')
D'autres mesures algorithmiques (Snowball) peuvent être effectuées pour réduire davantage les mots à leur sens essentiel.
Le remplacement des noms de couleurs par leurs équivalents hexadécimaux
La réduction des valeurs numériques par réduction de la précision constitue un autre moyen de normaliser le texte.
RESSOURCES
- http://linuxgazette.net/164/sephton.html
- http://Snowball.tartarus.org/
- Explication du score de recherche de MySQL Fulltext
- http://dev.mysql.com/doc/internals/en/full-text-search.html
- http://en.wikipedia.org/wiki/Vector_space_model
- http://en.wikipedia.org/wiki/Tf%E2%80%93idf
- http://phpir.com/simple-search-the-vector-space-model/
Si vous voulez éviter les problèmes "falsey" et "vérité", vous pouvez utiliser substr_count:
if (substr_count($a, 'are') > 0) {
echo "at least one 'are' is present!";
}
C'est un peu plus lent que strpos mais cela évite les problèmes de comparaison.
Une autre option consiste à utiliser la fonction strstr () . Quelque chose comme:
if (strlen(strstr($haystack,$needle))>0) {
// Needle Found
}
Pointez sur la note: la fonction strstr () est sensible à la casse. Pour une recherche ne respectant pas la casse, utilisez la fonction stristr () .
Je suis un peu impressionné par le fait qu'aucune des réponses ici qui utilisait strpos, strstr et les fonctions similaires mentionnées Fonctions de chaîne multi-octets (2015-05-08).
En gros, si vous rencontrez des difficultés pour trouver des mots avec des caractères spécifiques à certaines langues , tels que l'allemand, le français, le portugais, l'espagnol, etc. (par exemple: ä , é , ô , ç , º , ñ ), vous souhaiterez peut-être faire précéder les fonctions de _mb__. Par conséquent, la réponse acceptée utiliserait plutôt mb_strpos ou mb_stripos (pour la correspondance ne respectant pas la casse):
_if (mb_strpos($a,'are') !== false) {
echo 'true';
}
_Si vous ne pouvez pas garantir que toutes vos données sont à 100% en UTF-8 , vous pouvez utiliser les fonctions _mb__.
Un bon article pour comprendre pourquoi est Le minimum absolu que chaque développeur de logiciel a absolument, doit savoir positivement sur Unicode et les jeux de caractères (sans excuses!) par Joel Spolsky.
if (preg_match('/(are)/', $a)) {
echo 'true';
}
En PHP, le meilleur moyen de vérifier si une chaîne contient une certaine sous-chaîne est d'utiliser une fonction d'assistance simple comme celle-ci:
function contains($haystack, $needle, $caseSensitive = false) {
return $caseSensitive ?
(strpos($haystack, $needle) === FALSE ? FALSE : TRUE):
(stripos($haystack, $needle) === FALSE ? FALSE : TRUE);
}
Explication:
strposrecherche la position de la première occurrence d'une sous-chaîne sensible à la casse dans une chaîne.striposrecherche la position de la première occurrence d'une sous-chaîne insensible à la casse dans une chaîne.myFunction($haystack, $needle) === FALSE ? FALSE : TRUEgarantit quemyFunctionrenvoie toujours un booléen et corrige un comportement inattendu lorsque l'index de la sous-chaîne est 0.$caseSensitive ? A : Bsélectionne soitstrposoustripospour effectuer le travail , en fonction de la valeur de$caseSensitive.
Sortie:
var_dump(contains('bare','are')); // Outputs: bool(true)
var_dump(contains('stare', 'are')); // Outputs: bool(true)
var_dump(contains('stare', 'Are')); // Outputs: bool(true)
var_dump(contains('stare', 'Are', true)); // Outputs: bool(false)
var_dump(contains('hair', 'are')); // Outputs: bool(false)
var_dump(contains('aren\'t', 'are')); // Outputs: bool(true)
var_dump(contains('Aren\'t', 'are')); // Outputs: bool(true)
var_dump(contains('Aren\'t', 'are', true)); // Outputs: bool(false)
var_dump(contains('aren\'t', 'Are')); // Outputs: bool(true)
var_dump(contains('aren\'t', 'Are', true)); // Outputs: bool(false)
var_dump(contains('broad', 'are')); // Outputs: bool(false)
var_dump(contains('border', 'are')); // Outputs: bool(false)
La fonction ci-dessous fonctionne également et ne dépend d'aucune autre fonction. il utilise uniquement la manipulation de chaîne native PHP. Personnellement, je ne le recommande pas, mais vous pouvez voir comment cela fonctionne:
<?php
if (!function_exists('is_str_contain')) {
function is_str_contain($string, $keyword)
{
if (empty($string) || empty($keyword)) return false;
$keyword_first_char = $keyword[0];
$keyword_length = strlen($keyword);
$string_length = strlen($string);
// case 1
if ($string_length < $keyword_length) return false;
// case 2
if ($string_length == $keyword_length) {
if ($string == $keyword) return true;
else return false;
}
// case 3
if ($keyword_length == 1) {
for ($i = 0; $i < $string_length; $i++) {
// Check if keyword's first char == string's first char
if ($keyword_first_char == $string[$i]) {
return true;
}
}
}
// case 4
if ($keyword_length > 1) {
for ($i = 0; $i < $string_length; $i++) {
/*
the remaining part of the string is equal or greater than the keyword
*/
if (($string_length + 1 - $i) >= $keyword_length) {
// Check if keyword's first char == string's first char
if ($keyword_first_char == $string[$i]) {
$match = 1;
for ($j = 1; $j < $keyword_length; $j++) {
if (($i + $j < $string_length) && $keyword[$j] == $string[$i + $j]) {
$match++;
}
else {
return false;
}
}
if ($match == $keyword_length) {
return true;
}
// end if first match found
}
// end if remaining part
}
else {
return false;
}
// end for loop
}
// end case4
}
return false;
}
}
Tester:
var_dump(is_str_contain("test", "t")); //true
var_dump(is_str_contain("test", "")); //false
var_dump(is_str_contain("test", "test")); //true
var_dump(is_str_contain("test", "testa")); //flase
var_dump(is_str_contain("a----z", "a")); //true
var_dump(is_str_contain("a----z", "z")); //true
var_dump(is_str_contain("mystringss", "strings")); //true
Vous pouvez utiliser la fonction strstr:
$haystack = "I know programming";
$needle = "know";
$flag = strstr($haystack, $needle);
if ($flag){
echo "true";
}
Sans utiliser une fonction intégrée:
$haystack = "hello world";
$needle = "llo";
$i = $j = 0;
while (isset($needle[$i])) {
while (isset($haystack[$j]) && ($needle[$i] != $haystack[$j])) {
$j++;
$i = 0;
}
if (!isset($haystack[$j])) {
break;
}
$i++;
$j++;
}
if (!isset($needle[$i])) {
echo "YES";
}
else{
echo "NO ";
}
Cela me posait quelques problèmes et j'ai finalement choisi de créer ma propre solution. Sans utiliser le moteur expression régulière :
function contains($text, $Word)
{
$found = false;
$spaceArray = explode(' ', $text);
$nonBreakingSpaceArray = explode(chr(160), $text);
if (in_array($Word, $spaceArray) ||
in_array($Word, $nonBreakingSpaceArray)
) {
$found = true;
}
return $found;
}
Vous remarquerez peut-être que les solutions précédentes ne constituent pas une réponse pour le mot utilisé comme préfixe pour un autre. Pour utiliser votre exemple:
$a = 'How are you?';
$b = "a skirt that flares from the waist";
$c = "are";
Avec les exemples ci-dessus, $a et $b contiennent $c, mais vous pouvez souhaiter que votre fonction vous indique que seul $a contient $c.
Une autre option permettant de rechercher l'occurrence d'un mot à partir d'une chaîne à l'aide de strstr () et stristr () est la suivante:
<?php
$a = 'How are you?';
if (strstr($a,'are')) // Case sensitive
echo 'true';
if (stristr($a,'are')) // Case insensitive
echo 'true';
?>
Afin de trouver un "mot" plutôt que la survenue d'une série de lettres qui pourraient en fait faire partie d'un autre mot, voici la solution:.
$string = 'How are you?';
$array = explode(" ", $string);
if (in_array('are', $array) ) {
echo 'Found the Word';
}
Cela peut être fait de trois manières différentes:
$a = 'How are you?';
1- stristr ()
if (strlen(stristr($a,"are"))>0) {
echo "true"; // are Found
}
2- strpos ()
if (strpos($a, "are") !== false) {
echo "true"; // are Found
}
3- preg_match ()
if( preg_match("are",$a) === 1) {
echo "true"; // are Found
}
La version abrégée
$result = false!==strpos($a, 'are');
Peut-être que vous pourriez utiliser quelque chose comme ceci:
<?php
findWord('Test all OK');
function findWord($text) {
if (strstr($text, 'ok')) {
echo 'Found a Word';
}
else
{
echo 'Did not find a Word';
}
}
?>
Vous devez utiliser un format insensible à la casse. Ainsi, si la valeur entrée est dans small ou caps, cela n'aura aucune importance.
<?php
$grass = "This is pratik joshi";
$needle = "pratik";
if (stripos($grass,$needle) !== false) {
/*If i EXCLUDE : !== false then if string is found at 0th location,
still it will say STRING NOT FOUND as it will return '0' and it
will goto else and will say NOT Found though it is found at 0th location.*/
echo 'Contains Word';
}else{
echo "does NOT contain Word";
}
?>
Ici, stripos trouve une aiguille dans heystack sans en tenant compte de la casse (petite/majuscule).
Beaucoup de réponses qui utilisent substr_count vérifie si le résultat est _>0_. Mais puisque l'instruction if considère que zéro est le identique à false , vous pouvez éviter cette vérification et écrire directement:
_if (substr_count($a, 'are')) {
_Pour vérifier si n'est pas présent, ajoutez l'opérateur _!_:
_if (!substr_count($a, 'are')) {
_N'utilisez pas preg_match() si vous souhaitez uniquement vérifier si une chaîne est contenue dans une autre chaîne. Utilisez strpos() ou strstr() à la place car ils seront plus rapides. ( http://in2.php.net/preg_match )
if (strpos($text, 'string_name') !== false){
echo 'get the string';
}
Si vous voulez vérifier si la chaîne contient plusieurs mots spécifiques, vous pouvez faire:
$badWords = array("dette", "capitale", "rembourser", "ivoire", "mandat");
$string = "a string with the Word ivoire";
$matchFound = preg_match_all("/\b(" . implode($badWords,"|") . ")\b/i", $string, $matches);
if ($matchFound) {
echo "a bad Word has been found";
}
else {
echo "your string is okay";
}
Ceci est utile pour éviter les spams lors de l'envoi d'emails par exemple.
La fonction strpos fonctionne bien, mais si vous voulez vérifier case-insensitive pour rechercher un mot dans un paragraphe, vous pouvez utiliser la fonction stripos de PHP.
Par exemple,
$result = stripos("I love PHP, I love PHP too!", "php");
if ($result === false) {
// Word does not exist
}
else {
// Word exists
}
Recherchez la position de la première occurrence d'une sous-chaîne insensible à la casse dans une chaîne.
Si le mot n'existe pas dans la chaîne, il retournera faux sinon il retournera la position du mot.
Vous devez utiliser des opérateurs identiques/non identiques car strpos peut renvoyer 0 en tant que valeur d'index. Si vous aimez les opérateurs ternaires, envisagez d'utiliser ce qui suit (je l'admets, un peu en arrière):
echo FALSE === strpos($a,'are') ? 'false': 'true';
Vérifier si la chaîne contient des mots spécifiques?
Cela signifie que la chaîne doit être résolue en mots (voir la remarque ci-dessous).
Une façon de faire cela et de spécifier les séparateurs est d'utiliser preg_split ( doc ):
<?php
function contains_Word($str, $Word) {
// split string into words
// separators are substrings of at least one non-Word character
$arr = preg_split('/\W+/', $str, NULL, PREG_SPLIT_NO_EMPTY);
// now the words can be examined each
foreach ($arr as $value) {
if ($value === $Word) {
return true;
}
}
return false;
}
function test($str, $Word) {
if (contains_Word($str, $Word)) {
echo "string '" . $str . "' contains Word '" . $Word . "'\n";
} else {
echo "string '" . $str . "' does not contain Word '" . $Word . "'\n" ;
}
}
$a = 'How are you?';
test($a, 'are');
test($a, 'ar');
test($a, 'hare');
?>
Une course donne
$ php -f test.php
string 'How are you?' contains Word 'are'
string 'How are you?' does not contain Word 'ar'
string 'How are you?' does not contain Word 'hare'
Remarque: Ici, nous ne voulons pas dire mot pour chaque séquence de symboles.
Une définition pratique de Word est en ce sens le moteur d’expression régulière PCRE, où les mots sont des sous-chaînes composées uniquement de caractères Word, séparées par des caractères autres que Word.
Un caractère "mot" est une lettre ou un chiffre ou le caractère de soulignement, c'est-à-dire tout caractère pouvant faire partie d'un "mot" Perl. La définition des lettres et des chiffres est contrôlée par les tables de caractères de PCRE et peut varier si une correspondance spécifique aux paramètres régionaux est en cours (..)
Une chaîne peut être vérifiée avec la fonction ci-dessous:
function either_String_existor_not($str, $character) {
if (strpos($str, $character) !== false) {
return true;
}
return false;
}
Une autre solution pour une chaîne spécifique:
$subject = 'How are you?';
$pattern = '/are/';
preg_match($pattern, $subject, $match);
if ($match[0] == 'are') {
echo true;
}
Vous pouvez également utiliser la fonction strpos().
Utilisation:
$text = 'This is a test';
echo substr_count($text, 'is'); // 2
// So if you want to check if is exists in the text just put
// in a condition like this:
if (substr_count($text, 'is') > 0) {
echo "is exists";
}
Une option plus simple:
return ( ! empty($a) && strpos($a, 'are'))? true : false;
Je pense qu'une bonne idée est d'utiliser mb_stpos:
$haystack = 'How are you?';
$needle = 'are';
if (mb_strpos($haystack, $needle) !== false) {
echo 'true';
}
Parce que cette solution est sensible à la casse et sans danger pour tous les caractères Unicode.
Mais vous pouvez aussi le faire comme ceci ( la réponse de Sauch n'était pas encore ):
if (count(explode($needle, $haystack)) > 1) {
echo 'true';
}
Cette solution est également sensible à la casse et sans danger pour les caractères Unicode.
De plus vous n'utilisez pas la négation dans l'expression, ce qui augmente la lisibilité du code.
Voici une autre solution sing function:
function isContainsStr($haystack, $needle) {
return count(explode($needle, $haystack)) > 1;
}
if (isContainsStr($haystack, $needle)) {
echo 'true';
}
Utilisation:
$a = 'How are you?';
if (mb_strpos($a, 'are')) {
echo 'true';
}
Il effectue une opération strpos () sécurisée sur plusieurs octets.
Vous pouvez également utiliser les fonctions intégrées strchr() et strrchr() et les extensions pour les chaînes multi-octets mb_strchr() et mb_strrchr() . Ces fonctions renvoient des parties de chaînes et FALSE si rien n'est trouvé.
strchr()- Recherche la première occurrence d'une chaîne (est un alias destrstr()).strrchr()- Recherche la dernière occurrence d'un caractère dans une chaîne.