Comment puis-je vérifier si une chaîne contient un mot en particulier?

Vous pouvez utiliser des expressions régulières, c'est mieux pour le mot correspondant par rapport à strpos comme mentionné par d'autres utilisateurs, il reviendra également vrai pour les chaînes de caractères comme tarif, de soins, de stare, etc. Cela peut simplement être évitée dans l'expression régulière en utilisant les limites de mot.

Un match simple pour le pourrait ressembler à quelque chose comme ceci:

$a = 'How are you?';

if (preg_match('/\bare\b/', $a)) {
    echo 'true';
}

Du côté de la performance, strpos est environ trois fois plus vite et avoir à l'esprit, quand j'ai fait un million compare à la fois, il a fallu preg_match de 1,5 secondes pour terminer et pour strpos il a pris de 0,5 secondes.

Edit:
Pour la recherche d'une quelconque partie de la chaîne, et pas seulement de mot en mot, je vous conseille d'utiliser une expression régulière comme

$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 des modifications de l'expression régulière pour être sensible à la casse, si vous ne voulez pas, vous pouvez les laisser.

Maintenant, cela peut être très problématique dans certains cas, comme l' $chaîne de recherche n'est pas aseptisé de toute façon, je veux dire, il pourrait ne pas passer le vérifier dans certains cas, comme s' $search est une entrée de l'utilisateur, ils peuvent ajouter une chaîne de caractères qui peuvent se comporter comme des exemples de différents expression régulière...

Aussi, voici un excellent outil pour tester et voir les explications des différentes expressions régulières Regex101

De combiner les deux ensembles de fonctionnalités dans un seul multi-usage de la fonction (y compris avec une sélection sensible à la casse"), 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.
}

Alors que la plupart de ces réponses pourront vous dire si une sous-chaîne apparaît dans votre chaîne, ce n'est généralement pas ce que vous voulez si vous êtes à la recherche pour un particulier mot, et pas un sous-chaîne.

Quelle est la différence? Les chaînes peuvent apparaître dans d'autres mots:

• Le "sont" au début de la "zone"
• Le "sont" à la fin de "lièvre"
• Le "sont" au milieu de "tarifs"

Une façon d'atténuer ce serait d'utiliser une expression régulière couplée avec les limites de mot (\b):

function containsWord($str, $word)
{
    return !!preg_match('#\\b' . preg_quote($word, '#') . '\\b#i', $str);
}

Cette méthode n'a pas le même faux positifs indiqué ci-dessus, mais elle a quelques cas de bord de son propre. Les limites de mot de match sur la non-caractères de mot (\W), qui vont être quelque chose qui n'est pas a-z, A-Z, 0-9, ou _. Cela signifie que des chiffres et des caractères de soulignement sont va être compté comme la parole des personnages et des scénarios de ce genre de fail:

• Le "sont" dans "Ce _are_ pensez-vous?"
• Le "sont" dans "lol u ne sais pas wut ceux are4?"

Si vous voulez quelque chose de plus précis que cela, vous avez pour commencer à faire de l'anglais la langue de vérification de syntaxe, et c'est une assez grosse boîte de pandore (et suppose la bonne utilisation de la syntaxe, de toute façon, ce qui n'est pas toujours une donnée).

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

Peer to SamGoody et Lego Stormtroopr commentaires.

Si vous êtes à la recherche pour un PHP algorithme de rang des résultats de recherche basés sur la proximité et de la pertinence de plusieurs mots
voici un moyen facile et rapide de générer des résultats de recherche avec PHP seulement:

Questions avec l'autre les méthodes de recherche booléenne comme strpos(), preg_match(), strstr() ou stristr()

1. ne pouvez pas rechercher plusieurs mots
2. les résultats sont non-classé

PHP méthode basée sur Modèle Vectoriel et tf-idf (term frequency–inverse document frequency):

Il semble difficile mais il est étonnamment facile.

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

Si nous pouvions poids des termes dans une chaîne de caractères basé sur la façon dont ils sont représentatifs de la chaîne dans son ensemble,
nous pourrions commander nos résultats par ceux qui correspondent le mieux à la requête.

C'est l'idée du modèle vectoriel, non loin de la façon dont SQL de recherche de texte intégral d'œuvres:

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 naturels des requêtes,
qui n'ont pas les opérateurs booléens tels que strpos(), preg_match(), strstr() ou stristr().

NOTA BENE

Éventuellement éliminer la redondance avant de rechercher les mots

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

• moins d'I/O disque

• la rapidité d'indexation et, par conséquent, une recherche plus rapide.

1. Normalisation

• Convertir tout le texte en minuscules

2. Ignoré élimination

• Éliminer les mots du texte qui ne transportent pas de sens réel (comme 'et', 'ou', 'la', 'pour', etc.)

3. Dictionnaire de substitution

• Remplacer des mots par d'autres qui ont un produit identique ou similaire sens.
  (ex:remplacer les occurrences de "avidement" et "faim" avec la "faim")

• Plus d'algorithmique mesures (boule de neige) peuvent être effectuées pour réduire les mots à leur signification essentielle.

• Le remplacement des noms de couleur avec leurs équivalents hexadécimaux

• La réduction de valeurs numériques en réduisant la précision sont d'autres façons de normaliser le texte.

RESSOURCES

• http://linuxgazette.net/164/sephton.html
• http://snowball.tartarus.org/
• Recherche Fulltext MySQL Score Expliqué
• 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 "falsey" et "truthy" problème, 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 évite de la comparaison de problèmes.

Je suis un peu impressionnée par le fait qu'aucune des réponses ici strpos, strstr et des fonctions similaires mentionnés Fonctions De Chaînes De Caractères Multi-Octets encore (2015-05-08).

En gros, si vous êtes avoir de la difficulté à trouver des mots avec des caractères spécifiques à certaines langues, comme l'allemand, le français, le portugais, l'espagnol, etc. (par exemple: ä, é, ô, ç, º, ñ), vous pouvez faire précéder les fonctions avec mb_. Par conséquent, l'on a accepté la réponse serait d'utiliser mb_strpos ou mb_stripos (comparaison insensible à la casse) à la place:

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

Si vous ne pouvez pas garantir que l'ensemble de vos données est de 100% en UTF-8, vous pouvez utiliser le mb_ fonctions.

Un bon article pour comprendre pourquoi Le Minimum Absolu que Tout Développeur Doit Absolument, Positivement Savoir Sur Unicode et les Jeux de Caractères (Pas d'Excuses!) par Joel Spolsky.

La fonction ci-dessous qui fonctionne et ne dépend pas d'une autre fonction; il n'utilise que PHP natif de manipulation de chaîne. Personnellement, je ne recommande pas cela, 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;
}
}

Test:

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 

J'ai eu quelques difficultés avec cela, et finalement j'ai choisi de créer ma propre solution. Sans l'aide de expression régulière moteur:

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 pouvez remarquer que les solutions précédentes ne sont pas une réponse pour le mot étant utilisé comme préfixe pour l'autre. Afin d'utiliser votre exemple:

$a = 'How are you?';
$b = "a skirt that flares from the waist";
$c = "are";

Avec les exemples ci-dessus, les deux $a et $b contient $c, mais vous pourriez voulez que votre fonction pour vous dire que seuls les $a contient $c.

Une autre option pour trouver les occurrences d'un mot à partir d'une chaîne à l'aide de strstr() et stristr() est comme suit:

<?php
$a = 'How are you?';
if (strstr($a,'are'))  //Case sensitive
echo 'true';
if (stristr($a,'are'))  //Case insensitive
echo 'true';
?>

Court-version

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

Vous devez utiliser la casse de format,de sorte que si la valeur saisie est en small ou caps il l'habitude de la matière.

<?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 aiguille dans heystack sans considérant cas (petit/caps).

PHPCode Échantillon avec sortie

Peut-être vous pouvez 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';
}
}
?>

Si vous voulez vérifier si la chaîne contient plusieurs spécificités mots, vous pouvez le 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";
}

C'est utile pour éviter les spams, lors de l'envoi d'e-mails par exemple.

Vous devez utiliser identiques ou pas identiques opérateurs parce que strpos peut retourner 0 comme valeur de l'indice. Si vous aimez les opérateurs ternaires, l'utilisation de la suite (il semble un peu en arrière, je l'admets):

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

Une chaîne de caractères peut être vérifié avec le dessous de la fonction:

function either_String_existor_not($str, $character) {
if (strpos($str, $character) !== false) {
return true;
}
return false;
}

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

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 faire comme ceci (sauch réponse n'était pas encore):

if (count(explode($needle, $haystack)) > 1) {
echo 'true';
}

Cette solution est également sensible à la casse et sûr pour les caractères Unicode.

En outre, vous ne pas utiliser la négation de l'expression, qui augmente la lisibilité du code.

---

Ici est d'autre solution à l'aide de la fonction:

function isContainsStr($haystack, $needle) {
return count(explode($needle, $haystack)) > 1;
}
if (isContainsStr($haystack, $needle)) {
echo 'true';
}

Vous pouvez également utiliser les fonctions intégrées strchr() et strrchr() et des extensions pour les chaînes de caractères multi-octets mb_strchr() et mb_strrchr().
Ces fonctions retournent des parties de cordes, et FALSE si rien n'est trouvé.

• strchr() - Trouver la première occurrence d'une chaîne (qui est un alias de strstr()).
• strrchr() - Trouver la dernière occurrence d'un caractère dans une chaîne.