Jak sprawdzić, czy ciąg zawiera konkretne słowo?

Możesz używać wyrażeń regularnych, lepiej jest dopasowywać słowa w porównaniu do strpos, jak wspominają inni użytkownicy, zwróci również true dla ciągów takich jak fare, care, stare itp. Można tego po prostu uniknąć w wyrażeniu regularnym, używając granic wyrazów.

Proste dopasowanie do are może wyglądać mniej więcej tak:

$a = 'How are you?';

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

Po stronie wydajności, strpos jest około trzy razy szybszy i miej na uwadze, że gdy zrobiłem milion porównań na raz, zajęło to preg match 1.5 sekundy, aby zakończyć, a dla strpos zajęło 0,5 sekundy.

Oto mała funkcja użytkowa, która jest przydatna w takich sytuacjach

// returns true if $needle is a substring of $haystack
function contains($needle, $haystack)
{
    return strpos($haystack, $needle) !== false;
}

Podczas gdy większość z tych odpowiedzi powie Ci, czy w Twoim łańcuchu pojawi się substring, zwykle nie jest to to, czego chcesz, jeśli szukasz konkretnego słowa, a nie substring.

• "are" na początku "area"
• "są" na końcu "zająca"
• "są" w środku "taryfy"

Jednym ze sposobów złagodzenia tego byłoby użycie zwykłego wyrażenie połączone z granicami wyrazów (\b):

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

Ta metoda nie ma tych samych fałszywych alarmów opisanych powyżej, ale ma kilka własnych przypadków brzegowych. Granice słów dopasowują się do znaków nie-słownych (\W), które będą wszystkim, co nie jest a-z, A-Z, 0-9, lub _. Oznacza to, że cyfry i podkreślniki będą liczone jako znaki słowa i takie scenariusze zawiodą:

• "are" in " What _are_ you myślisz?"
• "są" w " lol u Nie wiem Wut those are4?"

Jeśli chcesz czegoś dokładniejszego niż to, będziesz musiał zacząć analizować składnię języka angielskiego, a to jest dość duża puszka robaków(i zakłada prawidłowe użycie składni, w każdym razie, co nie zawsze jest podane).

Aby określić, czy łańcuch zawiera inny łańcuch, możesz użyć funkcji 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";
}

?>

Uwaga:

Jeśli szukana igła znajduje się na początku stogu siana, zwróci pozycję 0, jeśli wykonasz == porównanie, które nie zadziała, musisz wykonać ===

A == Znak jest porównaniem i sprawdza, czy zmienna / wyrażenie / stała po lewej stronie ma taką samą wartość jak zmienna / wyrażenie / stała w prawo.

A === znak jest porównaniem, aby sprawdzić, czy dwie zmienne / wyrażenia / stałe są równe AND mają ten sam typ - tzn. obie są ciągami lub obie są liczbami całkowitymi.

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

Za pomocą strstr() lub stristr() Jeśli wyszukiwanie powinno być niewrażliwe na wielkość liter, to inna opcja.

Użyj dopasowania case-insensitve używając stripos():

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

Jeśli chcesz uniknąć problemu "false" I "True", możesz użyć substr_count:

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

Jest nieco wolniejszy niż strpos, ale unika problemów z porównaniem.

Peer do komentarzy SamGoody i Lego Stormtroopr.

Jeśli szukasz algorytmu PHP, aby uszeregować wyniki wyszukiwania na podstawie bliskości / trafności wielu słów oto szybki i łatwy sposób generowania wyników wyszukiwania tylko za pomocą PHP:

Problemy z innymi metodami wyszukiwania logicznego, takimi jak strpos(), preg_match(), strstr() lub stristr()

1. nie można szukać wielu słów
2. wyniki są Nieklasyfikowane

Metoda PHP na podstawie modelu przestrzeni wektorowej i TF-idf (term frequency-inverse document frequency):

Jeśli chcemy wyszukać wiele słów w ciągu głównym problemem jest to, jak przypisać wagę do każdego z nich?

Gdybyśmy mogli ważyć terminy w łańcuchu na podstawie tego, jak reprezentatywne są one dla łańcucha jako całości, możemy zamówić nasze wyniki według tych, które najlepiej pasują do zapytania.

To jest idea modelu przestrzeni wektorowej, niedaleko od tego, jak działa wyszukiwanie pełnotekstowe 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;
}

Przypadek 1

$query = 'are';

$corpus = array(
    1 => 'How are you?',
);

$match_results=get_similar_documents($query,$corpus);
echo '<pre>';
    print_r($match_results);
echo '</pre>';

Wynik

Array
(
    [1] => 0.52832083357372
)

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

Wyniki

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

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

Wyniki

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

Istnieje wiele ulepszeń do wprowadzenia ale model zapewnia sposób na uzyskanie dobrych wyników z naturalnych zapytań, które nie ma operatorów logicznych, takich jak strpos(), preg_match(), strstr() lub stristr().

NOTA BENE

Opcjonalnie wyeliminowanie redundancji przed wyszukaniem słów

• W ten sposób zmniejszając rozmiar indeksu i powodując mniejsze zapotrzebowanie na przechowywanie

• Less disk I / O

• Szybsze indeksowanie, a co za tym idzie Szybsze wyszukiwanie.

1. Normalizacja

• Konwertuj cały tekst na niższy case

2. Eliminacja Stopword

• Usuń z tekstu słowa, które nie mają rzeczywistego znaczenia (jak "i", "lub", "the", "for", itp.)

3. Substytucja słownika

• Zastąp słowa innymi, które mają identyczne lub podobne znaczenie. (ex: zastąp instancje "hungrily" i "hungry" słowem "hunger')

• Dalsze działania algorytmiczne (snowball) mogą być wykonywane w celu dalszego zmniejszenia słowa do ich istotnego znaczenia.

• Zastąpienie nazw kolorów ich szesnastkowymi odpowiednikami

• Redukcja wartości liczbowych poprzez zmniejszenie precyzji to inne sposoby normalizacji tekstu.

Zasoby

• http://linuxgazette.net/164/sephton.html
• http://snowball.tartarus.org/
• MySQL Fulltext Search Score Wyjaśnione
• 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/

Inną opcją jest użycie funkcji strstr () . Coś w stylu:

if (strlen(strstr($haystack,$needle))>0) {
// Needle Found
}

Zwróć uwagę: funkcja strstr () uwzględnia wielkość liter. Aby przeszukiwać wielkość liter, użyj funkcji stristr () .

Jestem trochę pod wrażeniem, że żadna z odpowiedzi tutaj, które używane strpos, strstr i podobne funkcje wymienione Multibyte String Functions jeszcze (2015-05-08).

Zasadniczo, jeśli masz problemy ze znalezieniem słów z znakami specyficznymi dla niektórych języków, takich jak niemiecki, francuski, portugalski, hiszpański itp. (np.: ä, é, ô, ç, º, ñ ), możesz poprzedzić funkcje za pomocą mb_. W związku z tym, zaakceptowana odpowiedź użyje mb_strpos lub mb_stripos (aby dopasować wielkość liter) zamiast:

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

Jeśli nie możesz zagwarantować, że wszystkie Twoje dane są w 100% w UTF-8, możesz użyć funkcji mb_.

Dobry artykuł, aby zrozumieć, dlaczego jest absolutne Minimum każdy programista absolutnie, pozytywnie musi wiedzieć o Unicode i zestawach znaków (bez wymówek!) przez Joel Spolsky.

Poniższa funkcja również działa i nie zależy od żadnej innej funkcji; używa tylko natywnej manipulacji łańcuchami PHP. Osobiście nie polecam tego, ale widać jak to działa:

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

if (preg_match('are', $a)) {
   echo 'true';
}

Miałem z tym pewne problemy i w końcu zdecydowałem się stworzyć własne rozwiązanie. Bez użycia wyrażenia regularnego silnik:

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

Możesz zauważyć, że poprzednie rozwiązania nie są odpowiedzią na słowo używane jako przedrostek dla innego. Aby skorzystać z przykładu:

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

Z przykładami powyżej, zarówno $a, jak i $b zawiera $c, ale możesz chcieć, aby Twoja funkcja powiedziała ci, że tylko $a zawiera $c.

Możesz użyć funkcji strstr:

$haystack = "I know programming";
$needle   = "know";
$flag = strstr($haystack, $needle);

if ($flag){

    echo "true";
}

Bez użycia wbudowanej funkcji:

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

W PHP, najlepszym sposobem sprawdzenia, czy łańcuch zawiera określony podłańcuch, jest użycie prostej funkcji pomocniczej, takiej jak:

function contains($haystack, $needle, $caseSensitive = false) {
    return $caseSensitive ?
            (strpos($haystack, $needle) === FALSE ? FALSE : TRUE):
            (stripos($haystack, $needle) === FALSE ? FALSE : TRUE);
}

Wyjaśnienie:

• strpos wyszukuje pozycję pierwszego wystąpienia fragmentu uwzględniającego wielkość liter w łańcuchu.
• stripos znajduje pozycję pierwszego wystąpienia niewrażliwego na wielkość liter fragmentu łańcucha.
• myFunction($haystack, $needle) === FALSE ? FALSE : TRUE zapewnia, że myFunction zawsze zwraca wartość logiczną i naprawia nieoczekiwane zachowanie gdy indeks podłańcucha wynosi 0.
• $caseSensitive ? A : B wybiera albo strpos lub stripos do wykonania pracy, w zależności od wartości $caseSensitive.

Wyjście:

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)

Wersja krótka

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

Aby znaleźć "słowo", a nie wystąpienie serii liter, które mogłyby w rzeczywistości być częścią innego słowa, dobrym rozwiązaniem byłoby następujące rozwiązanie.

$string = 'How are you?';
$array = explode(" ", $string);

if (in_array('are', $array) ) {
    echo 'Found the word';
}

Inną opcją znajdowania wystąpienia słowa Z ciągu znaków za pomocą strstr () i stristr () jest następujący:

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

Należy używać formatu niewrażliwego na wielkość liter,więc jeśli wprowadzona wartość jest w small lub caps, nie ma to znaczenia.

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

Tutaj stripos znajduje igłę w heystack Bez biorąc pod uwagę case (small/caps).

Próbka kodu PHP z wyjściem

Można to zrobić na trzy różne sposoby:

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

Wiele odpowiedzi, które używają substr_count sprawdza, czy wynikiem jest >0. Ale ponieważ if twierdzenie uważa zero za to samo co false, można uniknąć tego sprawdzenia i napisać bezpośrednio:

if (substr_count($a, 'are')) {

Aby sprawdzić, czy nie występuje, dodaj operator !:

if (!substr_count($a, 'are')) {

Może przydałoby ci się coś takiego:

<?php
    findWord('Test all OK');

    function findWord($text) {
        if (strstr($text, 'ok')) {
            echo 'Found a word';
        }
        else
        {
            echo 'Did not find a word';
        }
    }
?>

Nie używaj preg_match(), jeśli chcesz tylko sprawdzić, czy jeden łańcuch jest zawarty w innym łańcuchu. Użyj strpos() lub strstr() zamiast, ponieważ będą one szybsze. ( http://in2.php.net/preg_match )

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

Musisz użyć identycznych / nie identycznych operatorów, ponieważ strpos może zwrócić 0 jako wartość indeksu. Jeśli lubisz operatorów trójkowych, rozważ użycie następującego (wydaje się trochę wstecz, przyznaję):

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

Jeśli chcesz sprawdzić, czy łańcuch zawiera kilka konkretnych słów, możesz to zrobić:

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

Jest to przydatne, aby uniknąć spamu podczas wysyłania wiadomości e-mail na przykład.

Funkcja strpos działa dobrze, ale jeśli chcesz wykonać case-insensitive sprawdzanie słowa w akapicie, możesz użyć stripos funkcji PHP.

Na przykład,

$result = stripos("I love PHP, I love PHP too!", "php");
if ($result === false) {
    // Word does not exist
}
else {
    // Word exists
}

Znajdź pozycję pierwszego wystąpienia niewrażliwego na wielkość liter fragmentu łańcucha.

Jeśli słowo nie istnieje w łańcuchu, zwróci false, w przeciwnym razie zwróci pozycję słowa.

Sprawdzić, czy string zawiera konkretne słowa?

Oznacza to, że łańcuch musi zostać podzielony na słowa(patrz uwaga poniżej).

Jednym ze sposobów, aby to zrobić i określić separatory, jest użycie 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');

?>

A run gives

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

Uwaga: tutaj nie mamy na myśli słowa dla każdego ciągu symboli.

Praktyczną definicją słowa jest w tym sensie silnik wyrażeń regularnych PCRE, gdzie słowa są podciągami składającymi się ze słowa tylko znaki, oddzielone znakami Nie-słownymi.

Znak "słowo" to dowolna litera, cyfra lub znak podkreślenia, oznacza to, że każdy znak, który może być częścią "słowa" Perla. Na definicja liter i cyfr jest kontrolowana przez znak PCRE tabel, i mogą się różnić, jeśli ma miejsce dopasowanie specyficzne dla locale (..)

Łańcuch można sprawdzić za pomocą poniższej funkcji:

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