36 Question: Comment vérifier si une chaîne contient un mot spécifique?

question créée à Tue, May 1, 2018 12:00 AM

Considérez:

 
$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')?

    
2665
30 réponses                              30                         

Vous pouvez utiliser la fonction strpos() pour rechercher l'occurrence de 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; strpos() renvoie soit le décalage auquel la chaîne d'aiguille commence dans la chaîne de botte de foin, soit la valeur booléenne false si l'aiguille n'a pas été trouvée. Comme 0 correspond à un décalage valide et que 0 correspond à "falsey", nous ne pouvons pas utiliser de constructions plus simples, comme !strpos($a, 'are').

    
6211
2019-02-01 16: 52: 00Z
  1. Une des choses que j'ai trouvées est que si "are" est le premier mot, le code ci-dessus va échouer car il renvoie "0", ce qui peut être considéré comme faux! Pour éviter cela, il faut lire si (strpos ("x". $A, 'are')! == false) .....
    2011-08-16 16: 05: 01Z
  2. @ Darknight: "0" n'est pas considéré comme "faux" lorsque vous utilisez! ==. Il n’est pris en compte que si vous utilisez! =.
    2011-10-16 09: 12: 15Z
  3. Très tard pour la fête, mais faites attention à cela. Cela retournera également vrai pour la chaîne 'Do you care?'
    2012-09-28 00: 01: 59Z
  4. @ DTest - eh bien oui, bien sûr, il retournera la valeur true car la chaîne contient 'are'. Si vous recherchez spécifiquement le mot ARE, vous devrez effectuer plus de vérifications, par exemple, vérifiez s’il existe un caractère ou un espace avant le A et après le E.
    2012-11-14 21: 35: 52Z
  5. Très bons commentaires ci-dessus! Je n'utilise jamais! = Ou ==, après tout! == et === est la meilleure option (à mon avis) tous les aspects considérés (vitesse, précision, etc.).
    2012-12-15 12: 28: 17Z

Vous pouvez utiliser des expressions régulières, il vaut mieux pour la correspondance de mots que strpos, comme mentionné par d'autres utilisateurs, il retournera également la valeur true pour des chaînes telles que tarif, soin, regard, etc. limites.

Une simple correspondance 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. Si vous faites un million de comparaisons à la fois, cela prend preg_match 1,5 seconde pour terminer et pour strpos cela prenait 0,5 seconde.

Modifier: Afin de rechercher n'importe quelle partie de la chaîne, pas seulement mot par mot, je recommanderais d'utiliser une expression régulière telle que

.  
$a = 'How are you?';
$search 'are y';
if(preg_match("/{$search}/i", $a)) {
    echo 'true';
}

Le 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 pas assainie de quelque manière que ce soit, je ne veux pas dire qu'elle risque de ne pas être vérifiée dans certains cas. cela pourrait se comporter comme une expression régulière différente ...

En outre, voici un excellent outil pour tester et consulter les explications de diverses expressions régulières Regex101

Pour combiner les deux ensembles de fonctionnalités en une seule fonction multifonctions (y compris avec la sensibilité à la casse sélectionnable), vous pouvez utiliser quelque chose comme ceci:

 $search     
542
2019-04-24 05: 53: 34Z
  1. @ Alexander.Plutov Deuxièmement, vous me donnez -1 et pas la question? cmon il faut 2 secondes à Google pour répondre google.com/…
    2010-12-06 14: 03: 27Z
  2. + 1 C'est un moyen horrible de rechercher une chaîne simple, mais de nombreux visiteurs de SO recherchent un moyen quelconque de rechercher leurs propres sous-chaînes. utile que la suggestion a été soulevée. Même le PO aurait peut-être été trop simplifié: faites-lui savoir ses alternatives.
    2011-11-09 09: 53: 14Z
  3. Techniquement, la question demande comment trouver mots et non une sous-chaîne. Cela m’a effectivement aidée car je peux utiliser cela avec les limites de mots regex. Les alternatives sont toujours utiles.
    2013-08-20 05: 57: 04Z
  4. + 1 pour la réponse et -1 pour le commentaire @ plutov.by car, strpos est juste une vérification simple, entre-temps, vous pouvez vérifier plusieurs mots en même temps ex : preg_match (/êtes | vous | pas /)
    2014-11-05 17: 05: 34Z
  5. Les expressions régulières doivent être la méthode de dernier recours. Leur utilisation dans des tâches triviales devrait être découragée. J'insiste sur ce point depuis le sommet de nombreuses années de recherche de mauvais code.
    2015-02-18 14: 38: 15Z

Voici une petite fonction utilitaire utile dans des situations comme celle-ci

 
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.
}
    
230
2011-08-18 18: 54: 47Z
  1. @ RobinvanBaalen En fait, cela améliore la lisibilité du code. En outre, les votes négatifs sont censés être pour de (très) mauvaises réponses, pas pour des réponses "neutres".
    2013-07-09 08: 56: 33Z
  2. @ Les fonctions de RobinvanBaalen sont presque par définition lisibles (pour communiquer l'idée de ce que vous faites). Comparez ce qui est plus lisible:
    // returns true if $needle is a substring of $haystack
    function contains($needle, $haystack)
    {
        return strpos($haystack, $needle) !== false;
    }
    
    ou if ($email->contains("@") && $email->endsWith(".com)) { ...
    2013-07-25 12: 12: 48Z
  3. @ RobinvanBaalen dans les règles de fin sont censés être cassés. Sinon, les gens ne trouveraient pas de nouvelles façons inventives de faire les choses :). De plus, je dois admettre que j’ai du mal à comprendre les choses comme sur martinfowler.com. La meilleure chose à faire est d’essayer par vous-même et de déterminer les approches les plus pratiques.
    2013-08-22 01: 43: 18Z
  4. Autre opinion: disposer d'une fonction utilitaire que vous pouvez facilement encapsuler peut aider au débogage. En outre, cela motive de bons optimiseurs qui éliminent de tels frais généraux dans les services de production. Tous les avis ont donc des points valables. ;)
    2014-02-20 21: 09: 10Z
  5. Bien sûr, cela est utile. Vous devriez encourager ceci. Que se passe-t-il si, en PHP 100, il existe un nouveau moyen plus rapide de rechercher des emplacements de chaîne? Voulez-vous changer tous vos endroits où vous appelez strpos? Ou voulez-vous modifier uniquement les contenus dans la fonction ??
    2015-06-17 09: 44: 40Z

Alors que la plupart de ces réponses vous diront 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 , 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"

Un waPour atténuer ce risque, il faudrait utiliser une expression régulière associée aux limites de mot (if (strpos($email, "@") !== false && substr($email, -strlen(".com")) == ".com") { ...):

 \b

Cette méthode ne présente pas les mêmes faux positifs que ceux mentionnés ci-dessus, mais elle a ses propres cas. Les limites des mots correspondent aux caractères autres que les mots (

function containsWord($str, $word)
{
    return !!preg_match('#\\b' . preg_quote($word, '#') . '\\b#i', $str);
}
), qui ne seront pas \W, a-z, A-Z ou 0-9. Cela signifie que les chiffres et les traits de soulignement seront comptés comme des mots et que des scénarios comme celui-ci échoueront:
  • Les "sont" dans "Qu'est-ce que vous pensez?"
  • Les "sont" dans "lol u dunno wut ceux are4?"

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) .

    
129
2017-01-22 14: 39: 58Z
  1. ceci devrait être la réponse canonique. Parce que nous recherchons des mots et non des sous-chaînes , l'expression régulière est appropriée. J'ajouterai également que _ correspond à deux choses que \b ne correspond pas, ce qui le rend idéal pour rechercher des mots dans une chaîne: il correspond au début de la chaîne (\W) et à la fin de la chaîne (^)
    2014-10-12 02: 09: 57Z
  2. Cela ne fonctionne pas: 3v4l.org/vPk2V
    2016-06-23 08: 38: 07Z
  3. cela devrait être la bonne réponse .. le reste des réponses trouveront "sont" dans une chaîne du style "ça vous importe" .. Comme mentionné par @Dtest
    2016-06-30 07: 17: 58Z
  4. @ RobertSinclair Est-ce si grave? Si vous me demandiez si la chaîne "ça vous intéresse" contient le mot "are", je dirais "oui". Le mot "sont" est clairement une sous-chaîne de cette chaîne. C'est une question distincte de "" "Est" sont "l'un des mots de la chaîne" ça te concerne "" "".
    2016-07-05 19: 15: 14Z
  5. @ Paulpro Même si l'OP n'a pas spécifié le $a est une phrase, je suis presque sûr qu'elle était implicite. Donc, sa question était de savoir comment détecter le mot dans la phrase. Pas si un mot contient un mot à l'intérieur, ce qui, je suppose, serait sans importance le plus souvent.
    2016-07-06 22: 08: 35Z

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 ] )

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

<?php

$haystack = 'how are you';
$needle = 'are';

if (strpos($haystack,$needle) !== false) {
    echo "$haystack contains $needle";
}

?>
qui ne fonctionnera pas, vous devrez effectuer une ==

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 === du même type - c’est-à-dire que les deux sont des chaînes ou que les deux sont des entiers.

    
112
2018-07-30 10: 03: 48Z
  1. source de citation? maxi-pedia.com/string+contains+s+strstr+PHP
    2010-12-19 23: 39: 46Z

    Regardez AND :

     strpos()     
    60
    2013-09-24 18: 28: 24Z
    58
    2013-09-24 18: 31: 57Z
    1. Une note sur le php Page .net /manual /fr /function.strstr.php : Remarque: Si vous souhaitez uniquement déterminer si une aiguille particulière se produit dans une botte de foin, utilisez plutôt la fonction plus rapide et moins gourmande en mémoire, strpos ().
      2014-02-08 17: 49: 15Z
    2. @ tastro Existe-t-il des points de repère réputés à ce sujet?
      2014-06-17 10: 26: 44Z
    3. Cela pourrait être plus lent, mais IMHO stristr() est beaucoup plus élégant que le laid strstr($a, 'are'). PHP a vraiment besoin d’une fonction strpos($a, 'are') !== false.
      2018-03-15 10: 57: 02Z

    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 moyen rapide et facile 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 str_contains(), strpos(), preg_match() ou strstr()

    1. ne peut pas rechercher plusieurs mots
    2. les résultats ne sont pas classés

    Méthode PHP basée sur le modèle d'espace vectoriel et tf-idf (fréquence de document - fréquence de document inverse):

    Cela semble difficile mais étonnamment facile.

    Si nous voulons rechercher plusieurs mots dans une chaîne, le problème fondamental est de savoir comment attribuer un poids à chacun d'entre eux?

    Si nous pouvions pondérer les termes d'une chaîne en fonction de leur représentativité de la chaîne dans son ensemble, nous pourrions classer nos résultats par ceux qui correspondent le mieux à la requête.

    C’est l’idée du modèle d’espace vectoriel, tout près du fonctionnement de la recherche de texte intégral SQL:

     stristr()

    CAS 1

     
    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;
    }
    

    RÉSULTAT

     
    $query = 'are';
    
    $corpus = array(
        1 => 'How are you?',
    );
    
    $match_results=get_similar_documents($query,$corpus);
    echo '<pre>';
        print_r($match_results);
    echo '</pre>';
    

    CAS 2

     
    Array
    (
        [1] => 0.52832083357372
    )
    

    RÉSULTATS

     
    $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>';
    

    CAS 3

     
    Array
    (
        [1] => 0.54248125036058
        [3] => 0.21699250014423
    )
    

    RÉSULTATS

     
    $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>';
    

    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

    Array
    (
        [3] => 0.6813781191217
        [1] => 0.54248125036058
    )
    
    , strpos(), preg_match() ou strstr().

    NOTA BENE

    Éliminer éventuellement la redondance avant de rechercher les mots

    • réduisant ainsi la taille de l'index et réduisant les besoins en stockage

    • moins d'E /S disque

    • indexation plus rapide et, par conséquent, recherche plus rapide.

    1. Normalisation

    • Convertir tout le texte en minuscules

    2. Élimination des mots vides

    • Supprimez du texte les mots qui n'ont pas de signification réelle (comme 'et', 'ou', 'le', 'pour', etc.)

    3. Substitution de dictionnaire

    • Remplacez les mots par d'autres qui ont une signification identique ou similaire. (par exemple, remplacez les expressions "affamé" et "affamé" par "faim")

    • D'autres mesures algorithmiques (boule de neige) peuvent être effectuées pour réduire davantage les mots à leur sens essentiel.

    • Remplacement des noms de couleurs par leurs équivalents hexadécimaux

    • La réduction des valeurs numériques en réduisant la précision est un autre moyen de normaliser le texte.

    RESSOURCES

    43
    2017-12-24 11: 14: 57Z

    Utilisez la correspondance sans distinction de casse avec stristr() :

     stripos()     
    42
    2014-05-25 03: 49: 35Z

    Si vous voulez éviter les problèmes "falsey" et "vérité", vous pouvez utiliser substr_count:

     
    if (stripos($string,$stringToSearch) !== false) {
        echo 'true';
    }
    

    C'est un peu plus lent que strpos mais cela évite les problèmes de comparaison.

        
    40
    2013-07-09 08: 38: 53Z

    Une autre option consiste à utiliser la fonction strstr () . Quelque chose comme:

     
    if (substr_count($a, 'are') > 0) {
        echo "at least one 'are' is present!";
    }
    

    Point à noter: la fonction strstr () est sensible à la casse. Pour une recherche ne respectant pas la casse, utilisez la fonction stristr () .

        
    31
    2012-08-20 16: 20: 31Z
    1. strstr () renvoie FALSE si l'aiguille n'a pas été trouvée. Un strlen n'est donc pas nécessaire.
      2012-09-11 04: 13: 10Z
    2. bon travail pour tenir compte de la casse avec
      if (strlen(strstr($haystack,$needle))>0) {
      // Needle Found
      }
      
      2015-08-06 17: 23: 32Z

    Je suis un peu impressionné par le fait qu'aucune des réponses ici qui utilisaient stristr(), strpos et les fonctions similaires mentionnées Fonctions sur les chaînes de caractères multi-octets (2015-05-08).

    Si vous rencontrez des difficultés pour trouver des mots comportant 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 avec strstr. Par conséquent, la réponse acceptée utiliserait mb_ ou mb_strpos (pour la correspondance ne respectant pas la casse) à la place:

     mb_stripos

    Si vous ne pouvez pas garantir que toutes vos données sont à 100% en UTF-8 , vous voudrez peut-être utiliser les fonctions

    if (mb_strpos($a,'are') !== false) {
        echo 'true';
    }
    
    .

    Un bon article pour comprendre pourquoi Le minimum absolu que tout développeur de logiciel logiciel doit absolument, positivement Connaître l'Unicode et les jeux de caractères (pas d'excuses!) par Joel Spolsky .

        
    28
    2017-05-23 12: 34: 57Z
     mb_     
    28
    2018-10-14 20: 46: 24Z
    1. c'est vrai. mieux utiliser "preg_match ()"
      2013-10-30 16: 10: 22Z
    2. Je reçois l'avertissement suivant:
      if (preg_match('/(are)/', $a)) {
         echo 'true';
      }
      
      2016-08-10 17: 06: 13Z

    La fonction ci-dessous fonctionne également et ne dépend d'aucune autre fonction. il utilise uniquement la manipulation de chaînes PHP native. Personnellement, je ne le recommande pas, mais vous pouvez voir comment cela fonctionne:

     WARNING preg_match(): Delimiter must not be alphanumeric or backslash

    Test:

     
    <?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;
      }
    }
    
        
    23
    2015-05-18 10: 45: 06Z
    1. Pourriez-vous me dire pourquoi, dans le monde, vous utiliseriez une fonction comme celle-ci, lorsque strpos est une solution parfaitement viable? ...
      2013-09-19 14: 05: 59Z
    2. @ sg3s: vous avez tout à fait raison, cependant, les strpos sont également basés sur quelque chose comme ça, aussi, je ne l'ai pas posté pour le représentant simplement pour partager un peu de connaissances
      2013-09-19 19: 33: 15Z
    3. dernier var_dump est faux
      2015-05-17 21: 29: 31Z
    4. @ Sunny: c'était une faute de frappe: var_dump (is_str_contain ("mystringss", "strings")); //true
      2015-05-18 10: 44: 27Z

    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:

     
    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 
    

    Explication:

    Sortie:

     $caseSensitive     
    22
    2017-12-12 16: 48: 01Z

    J'ai eu quelques problèmes avec cela, et finalement j'ai choisi de créer ma propre solution. Sans utiliser le moteur expression régulière :

     
    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)
    

    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:

     
    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;
     }
    

    Avec les exemples ci-dessus,

    $a = 'How are you?';
    $b = "a skirt that flares from the waist";
    $c = "are";
    
    et $a contiennent $b, mais vous souhaitez peut-être que votre fonction vous indique que seul $c en contient $a.     
    21
    2016-06-25 19: 30: 08Z
    1. vous vouliez probablement dire: $c au début
      2015-03-04 12: 36: 55Z
    2. votre fonction peut ne pas fonctionner si le mot est lié à une virgule, un point d'interrogation ou un point. par exemple. "Ce que vous voyez est ce que vous obtenez." et vous voulez déterminer si "get" est dans la phrase. Remarquez l'arrêt complet à côté de "get". Dans ce cas, votre fonction renvoie false. il est recommandéo utiliser une expression régulière ou une sous-chaîne (je pense qu’elle utilise quand même une expression régulière) pour rechercher /remplacer des chaînes.
      2015-04-15 06: 12: 27Z
    3. @ lightbringer, vous ne pouvez pas vous tromper davantage avec votre recommandation, qu'est-ce que cela signifie pour vous "il est recommandé"? il n'y a pas de personne suprême qui recommande ou approuve. Il s’agit de l’utilisation du moteur d’expression régulière en php qui constitue un trou noir dans le langage lui-même; vous pouvez essayer de mettre une correspondance de regex dans une boucle et d’évaluer les résultats.
      2015-04-16 11: 46: 52Z

    Vous pouvez utiliser la fonction $found = false:

     strstr

    Sans utiliser de fonction intégrée:

     
    $haystack = "I know programming";
    $needle   = "know";
    $flag = strstr($haystack, $needle);
    
    if ($flag){
    
        echo "true";
    }
    
        
    21
    2017-05-21 11: 26: 37Z
    1. plantation si vous recherchez le premier mot.
      2016-03-21 12: 28: 30Z

    Une autre option pour rechercher l'occurrence d'un mot dans une chaîne à l'aide de strstr () et stristr () est similaire à ce qui suit:

     
    $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 ";
    }
    
        
    17
    2016-06-25 19: 30: 52Z
    1. C'est en arrière. Le
      <?php
          $a = 'How are you?';
          if (strstr($a,'are'))  // Case sensitive
              echo 'true';
          if (stristr($a,'are'))  // Case insensitive
              echo 'true';
      ?>
      
      sur i signifie insensible.
      2014-04-01 02: 20: 56Z

    Cela peut se faire de trois manières différentes:

     stristr

    1- stristr ()

     
     $a = 'How are you?';
    

    2- strpos ()

     
     if (strlen(stristr($a,"are"))>0) {
        echo "true"; // are Found
     } 
    

    3- preg_match ()

     
     if (strpos($a, "are") !== false) {
       echo "true"; // are Found
     }
    
        
    14
    2015-12-28 04: 28: 02Z
    1. Bon, mais preg_match est risqué car il peut renvoyer false ou 0. Vous devriez effectuer un test === 1 sur # 3
      2015-12-28 04: 10: 37Z

    La version abrégée

     
     if( preg_match("are",$a) === 1) {
       echo "true"; // are Found
     }
    
        
    14
    2016-03-20 17: 38: 15Z
    1. Bien que cet extrait de code puisse résoudre la question, inclure une explication contribue réellement à améliorer la qualité de votre message N'oubliez pas que vous répondez à la question pour les lecteurs à l'avenir et que ces personnes risquent de ne pas connaître les raisons de votre suggestion de code.
      2015-03-13 13: 23: 28Z

    Pour trouver un "mot" plutôt que la présence d'une série de lettres qui pourraient en fait faire partie d'un autre mot, voici une bonne solution.

     
    $result = false!==strpos($a, 'are');
    
        
    14
    2016-06-25 19: 25: 09Z
    1. il échouera si
      $string = 'How are you?';
      $array = explode(" ", $string);
      
      if (in_array('are', $array) ) {
          echo 'Found the word';
      }
      
      est $string
      2015-05-17 21: 35: 29Z

    Vous devez utiliser un format ne tenant pas compte de la casse. Ainsi, si la valeur entrée est dans Are are, are? ou small, cela n'aura aucune importance.

     caps

    Ici, le stripos trouve une aiguille dans la pile de stockage sans prendre en compte le cas (petites /majuscules).

    Exemple de code PHPCode avec une sortie

        
    13
    2015-09-08 11: 00: 06Z
    1. ne fonctionne pas si
      <?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";
      }
      ?>
      
      = > codepad.org/wUIKQ0A8
      2016-09-09 11: 53: 13Z

    Beaucoup de réponses qui utilisent $needle = "this"; vérifient si le résultat est substr_count . Mais comme l'instruction >0 considère que zéro est identique à false , vous pouvez éviter cette vérification. et écrivez directement:

     if

    Pour vérifier si pas n'est pas présent, ajoutez l'opérateur

    if (substr_count($a, 'are')) {
    
    :  !     
    13
    2017-12-21 11: 21: 22Z
    1. Bien ... partiellement vrai, en php 0 == faux est vrai, mais 0 === faux est faux
      2017-03-10 09: 34: 56Z

    Peut-être pourriez-vous utiliser quelque chose comme ceci:

     
    if (!substr_count($a, 'are')) {
    
        
    12
    2016-06-25 19: 26: 54Z

    N'utilisez pas

    <?php
        findWord('Test all OK');
    
        function findWord($text) {
            if (strstr($text, 'ok')) {
                echo 'Found a word';
            }
            else
            {
                echo 'Did not find a word';
            }
        }
    ?>
    
    si vous souhaitez uniquement vérifier si une chaîne est contenue dans une autre chaîne. Utilisez plutôt preg_match() ou strpos() car ils seront plus rapides. ( http://in2.php.net/preg_match )  strstr()     
    11
    2014-04-05 11: 49: 13Z

    Si vous voulez vérifier si la chaîne contient plusieurs mots spécifiques, vous pouvez faire:

     
    if (strpos($text, 'string_name') !== false){
       echo 'get the string';
    }
    

    Ceci est utile pour éviter le spam lors de l'envoi d'e-mails par exemple.

        
    11
    2016-06-25 19: 17: 33Z

    La fonction strpos fonctionne bien, mais si vous voulez vérifier un mot dans un paragraphe

    $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";
    }
    
    , vous pouvez utiliser la fonction case-insensitive de stripos.

    Par exemple,

     PHP

    Trouvez 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 renverra false sinon il renverra la position du mot.

        
    10
    2017-01-05 14: 16: 57Z

    Vous devez utiliser des opérateurs identiques /non identiques car strpos peut renvoyer 0 comme valeur d'index. Si vous aimez les opérateurs ternaires, envisagez les solutions suivantes (un peu en arrière, je l’admets):

     
    $result = stripos("I love PHP, I love PHP too!", "php");
    if ($result === false) {
        // Word does not exist
    }
    else {
        // Word exists
    }
    
        
    9
    2016-02-21 18: 25: 42Z
      

    Vérifiez 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

    echo FALSE === strpos($a,'are') ? 'false': 'true';
    
    ( doc ):  preg_split

    Une course donne

     
    <?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');
    
    ?>
    

    Remarque: Nous ne voulons pas dire ici par mot pour chaque séquence de symboles.

    Une définition pratique de mot correspond au sens du moteur d’expression régulière PCRE, dans lequel les mots sont des sous-chaînes composées uniquement de caractères, séparés par des caractères autres que des mots.

      

    Un caractère "mot" est une lettre, un chiffre ou le trait de soulignement.   c'est-à-dire tout caractère pouvant faire partie d'un "mot" Perl. le   la définition des lettres et des chiffres est contrôlée par le caractère de PCRE   tables, et peut varier si une correspondance spécifique à l'environnement local est en cours (..)

        
    8
    2015-09-23 23: 37: 08Z

    Une chaîne peut être vérifiée avec la fonction ci-dessous:

     
    $ 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'
    
        
    7
    2016-07-13 03: 41: 47Z
    1. peut être simplifié à
      function either_String_existor_not($str, $character) {
          if (strpos($str, $character) !== false) {
              return true;
          }
          return false;
      }
      
      2016-08-19 16: 57: 23Z
    2. qu'est-ce qui se passe si la chaîne est "ça vous importe" alors
      2016-11-16 16: 19: 02Z
    return strpos($str, $character) !== false
source placée ici