it-swarm-fr.com

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

2664
Charles Yeung

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

6343
codaddict

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.
}
_
557
Breezer

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

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

131
FtDRbwLXw6

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.

119
Jose Vega

Regardez strpos() :

<?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.";
    }
?>
63
Haim Evgi

Utiliser strstr() ou stristr() si votre recherche devait être sensible à la casse, ce serait une autre option.

59
glutorange

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

  1. ne peut pas rechercher plusieurs mots
  2. 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

44
RafaSashi

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.

40
Alan Piralla

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

30
YashG99

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.

28
Armfoot
if (preg_match('/(are)/', $a)) {
   echo 'true';
}
28
joan16v

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:

  • strpos recherche la position de la première occurrence d'une sous-chaîne sensible à la casse dans une chaîne.
  • stripos recherche la position de la première occurrence d'une sous-chaîne insensible à la casse dans une chaîne.
  • myFunction($haystack, $needle) === FALSE ? FALSE : TRUE garantit que myFunction renvoie toujours un booléen et corrige un comportement inattendu lorsque l'index de la sous-chaîne est 0.
  • $caseSensitive ? A : B sélectionne soit strpos ou stripos pour 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)
23
John Slegers

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 
22
Jason OOO

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 ";
}
21
Arshid KV

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.

20
Decebal

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';
?>
17
Sadikhasan

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';
}
14
DJC

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
 }
14
Shashank Singh

La version abrégée

$result = false!==strpos($a, 'are');
14
Somwang Souksavatd

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';
        }
    }
?>
13
Mathias Stavrou

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

PHPCode Échantillon avec sortie

13
Pratik

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')) {
_
13
T30

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';
}
12
Vinod Joshi

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.

11
Julien

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.

10
Akshay Khale

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';
9
Shapeshifter

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

8
mvw

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

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

6
devpro

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";
}
5
Kamaro Lambert

Une option plus simple:

return ( ! empty($a) && strpos($a, 'are'))? true : false;
4
ShirleyCC

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';
}
4
simhumileco

Utilisation:

$a = 'How are you?';
if (mb_strpos($a, 'are')) {
    echo 'true';
}

Il effectue une opération strpos () sécurisée sur plusieurs octets.

3
Mindexperiment

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 de strstr() ).
  • strrchr() - Recherche la dernière occurrence d'un caractère dans une chaîne.
3
Aleksey Bykov