Bir dizenin belirli bir kelime içerip içermediğini nasıl kontrol ederim?

Düşünmek:

$a = 'How are you?';

if ($a contains 'are')
    echo 'true';

Yukarıdaki kodu aldığımı varsayalım, ifadeyi yazmanın doğru yolu if ($a contains 'are')nedir?

strpos()Bir dizenin bir diğerinin içindeki oluşumunu bulmak için kullanılan işlevi kullanabilirsiniz :

$a = 'How are you?';

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

Kullanımının !== falsekasıtlı olduğuna dikkat edin ( istenen sonucu != falsene === truedöndürmez ne de döndürür); strpos()samanlık dizesinde iğne dizesinin başladığı ofseti veya falseiğne bulunmazsa boole değerini döndürür . 0 geçerli bir ofset ve 0 "falsey" olduğundan, gibi daha basit yapıları kullanamayız !strpos($a, 'are').

Düzenli ifadeler kullanabilirsiniz, strposdiğer kullanıcılar tarafından belirtildiği gibi kelime eşleme için daha iyidir , ayrıca ücret, bakım, bakış, vb gibi dizeler için de doğru dönecektir. Bu, sözcük sınırlarını kullanarak normal ifadede önlenebilir.

İçin basit bir eşleşme şöyle görünebilir:

$a = 'How are you?';

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

Performans tarafında, strposyaklaşık üç kat daha hızlı ve aklımda, bir kerede bir milyon karşılaştırma yaptığımda, preg_matchbitirmek 1.5 saniye strpossürdü ve 0.5 saniye sürdü.

Düzenleme: Sadece kelime kelime değil, dizenin herhangi bir bölümünü aramak için, gibi normal bir ifade kullanmanızı tavsiye ederim

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

iNormal ifadenin sonunda bunu istemiyorsanız, bunu dışarı bırakabilir, büyük küçük harf duyarsız olması normal ifadeyi değiştirir.

Şimdi, bu, $ arama dizesi herhangi bir şekilde sterilize edilmediğinden, bazı durumlarda oldukça sorunlu olabilir, yani, bazı durumlarda denetimi geçmeyebilir, sanki $searchbir kullanıcı girişi gibi davranabilirler. bazı farklı düzenli ifadeler ...

Ayrıca, burada çeşitli düzenli ifadelerin açıklamalarını test etmek ve görmek için harika bir araç Regex101

Her iki işlevsellik kümesini tek bir çok amaçlı işlevde (seçilebilir büyük / küçük harf duyarlılığı dahil) birleştirmek için aşağıdaki gibi bir şey kullanabilirsiniz:

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

İşte böyle durumlarda yararlı küçük bir yardımcı program işlevi

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

Bu cevapların çoğu dizenizde bir alt dize belirip belirmediğini size söylese de, genellikle bir alt dize değil, belirli bir kelimeyi arıyorsanız istediğiniz şey değildir .

Fark ne? Alt dizeler başka kelimelerle de görünebilir:

• "Alan" ın başında "vardır"
• "Tavşan" ın sonunda "vardır"
• "Ücretler" ortasında "vardır"

Bunu hafifletmenin bir yolu, kelime sınırları ( \b) ile birlikte düzenli bir ifade kullanmaktır :

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

Bu yöntem, yukarıda belirtilen aynı yanlış pozitiflere sahip değildir, ancak kendi uç durumlarına sahiptir. Sözcük sınırları olmayan kelime karakterler (eşleştirilecek \Wdeğil bir şey olacak), a-z, A-Z, 0-9, veya _. Bu, rakamların ve alt çizgilerin kelime karakterleri olarak sayılacağı ve bunun gibi senaryoların başarısız olacağı anlamına gelir:

• "Ne düşünüyorsun?"
• "Are" içinde "lol u dunno wut bu are4?"

Bundan daha doğru bir şey istiyorsanız, İngilizce sözdizimi ayrıştırma yapmaya başlamanız gerekir ve bu oldukça büyük bir solucan kutusu (ve her zaman verilen bir sözdiziminin düzgün kullanılmadığını varsayar).

Bir dizenin başka bir dizgi içerip içermediğini belirlemek için PHP işlev strpos () işlevini kullanabilirsiniz .

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

?>

DİKKAT:

Aradığınız iğne samanlığın başlangıcındaysa, 0 konumuna dönecektir, eğer işe yaramayacak bir ==karşılaştırma yaparsanız,===

Bir ==işaret bir karşılaştırmadır ve soldaki değişken / ifade / sabitin sağdaki değişken / ifade / sabitle aynı değere sahip olup olmadığını test eder.

Bir ===işaret, iki değişkenin / ifadenin / sabitin eşit olup olmadığını görmek için bir karşılaştırmadır AND- yani her ikisi de dize veya her ikisi de tamsayıdır.

Şuna bakstrpos() :

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

Kullanılması strstr()veya stristr()arama olmalıdır eğer durum duyarsız başka bir seçenek olacaktır.

Büyük / küçük harf duyarsız eşleştirmeyi kullanarak stripos()şunları kullanın :

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

SamGoody ve Lego Stormtroopr'a göz atın.

Birden fazla kelimenin yakınlığına / alaka düzeyine göre arama sonuçlarını sıralamak için bir PHP algoritması arıyorsanız, burada sadece PHP ile arama sonuçları oluşturmanın hızlı ve kolay bir yolu gelir:

Diğer boolean arama yöntemleriyle ilgili sorunlar gibi strpos(), preg_match(), strstr()veyastristr()

1. birden fazla kelime arayamıyorum
2. sonuçlar doğrulanmamış

Vector Space Modeli ve tf-idf (terim sıklığı - ters belge sıklığı) tabanlı PHP yöntemi :

Kulağa zor geliyor ama şaşırtıcı derecede kolay.

Bir dizede birden fazla kelime aramak istiyorsak, temel sorun, her birine nasıl ağırlık atadığımızdır?

Bir dizedeki terimleri bir bütün olarak dizenin temsilcisine göre ağırlıklandırabiliyorsak, sonuçlarımızı sorguyla en iyi eşleşenlere göre sıralayabiliriz.

Bu, SQL tam metin aramasının nasıl çalıştığından çok uzak olmayan vektör uzay modeli fikridir :

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

DAVA 1

$query = 'are';

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

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

SONUÇ

Array
(
    [1] => 0.52832083357372
)

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

SONUÇLAR

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

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

SONUÇLAR

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

Orada yapılacak iyileştirmelerin bol ama modeli gibi bağlaçlar yok doğal sorgular, iyi sonuçlar almanın bir yol sağlar strpos(), preg_match(), strstr()veya stristr().

NOTA BENE

İsteğe bağlı olarak, kelimeleri aramadan önce artıklığı ortadan kaldırma

• böylece dizin boyutunu azaltır ve daha az depolama gereksinimi sağlar

• daha az disk G / Ç

• daha hızlı indeksleme ve sonuç olarak daha hızlı bir arama.

1. Normalleştirme

• Tüm metni küçük harfe dönüştür

2. Engellenecek kelime eliminasyonu

• Gerçek anlam taşımayan metindeki kelimeleri ortadan kaldırın ('ve', 'veya', '', 'için' vb.)

3. Sözlük değiştirme

• Kelimeleri aynı veya benzer bir anlama sahip başkalarıyla değiştirin. (ör: 'aç' ve 'aç' örneklerini 'açlık' ile değiştir)

• Kelimeleri temel anlamlarına daha da azaltmak için başka algoritmik önlemler (kartopu) yapılabilir.

• Renk adlarının onaltılık eşdeğerleriyle değiştirilmesi

• Hassasiyeti azaltarak sayısal değerlerin azaltılması, metni normalleştirmenin diğer yoludur.

KAYNAKLAR

• http://linuxgazette.net/164/sephton.html
• http://snowball.tartarus.org/
• MySQL Tam Metin Arama Puanı Açıklaması
• 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/

"Falsey" ve "doğruluk" sorunlarından kaçınmak istiyorsanız, substr_count komutunu kullanabilirsiniz:

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

Strpos'tan biraz daha yavaş ama karşılaştırma problemlerinden kaçınıyor.

Başka bir seçenek strstr () işlevini kullanmaktır. Gibi bir şey:

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

Dikkat edilmesi gereken nokta: strstr () işlevi büyük / küçük harfe duyarlıdır. Büyük / küçük harfe duyarlı olmayan bir arama için stristr () işlevini kullanın.

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

Biraz kullanılan burada cevapları hiçbirinin etkiledi değilim strpos, strstrve benzeri fonksiyonlar söz baytlı Dizge İşlevleri henüz (2015-05-08).

Temel olarak, Almanca, Fransızca, Portekizce, İspanyolca vb. Gibi bazı dillere özgü karakterleri olan kelimeleri bulmakta sorun yaşıyorsanız (örn: ä , é , ô , ç , º , ñ ), ile fonksiyonları mb_. Bu nedenle, kabul edilen cevap bunun yerine mb_strposveya mb_stripos(büyük / küçük harf duyarsız eşleme için) kullanır:

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

UTF-8'de tüm verilerinizin% 100 olduğunu garanti edemezseniz , mb_işlevleri kullanmak isteyebilirsiniz .

İyi bir makale olduğunu anlamak Mutlak Asgari Her Yazılım Geliştirici Kesinlikle, Olumlu Unicode ve Karakter Kümeleri (No Bahane!) Hakkında bilmeniz gereken tarafından Joel Spolsky .

PHP'de, bir dizenin belirli bir alt dize içerip içermediğini doğrulamanın en iyi yolu, aşağıdaki gibi basit bir yardımcı işlev kullanmaktır:

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

Açıklama:

• strpos bir dizedeki büyük / küçük harfe duyarlı bir alt dize oluşumunun konumunu bulur.
• stripos dizede büyük / küçük harfe duyarlı olmayan bir alt dizenin ilk oluşumunun konumunu bulur.
• myFunction($haystack, $needle) === FALSE ? FALSE : TRUEolmasını sağlar myFunctionalt dize endeksi 0 olduğunda her zaman bir boolean ve düzeltmeler beklenmeyen davranışlar döndürür.
• $caseSensitive ? A : Bdeğerine bağlı olarak strposveya striposişi yapmak için seçim yapar $caseSensitive.

Çıktı:

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)

Aşağıdaki işlev de çalışır ve başka herhangi bir işleve bağlı değildir; yalnızca yerel PHP dize manipülasyonu kullanır. Şahsen, bunu önermiyorum, ancak nasıl çalıştığını görebilirsiniz:

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

Ölçek:

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 

strstrİşlevi kullanabilirsiniz :

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

if ($flag){

    echo "true";
}

Dahili bir fonksiyon kullanmadan:

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

Bununla ilgili bir sorunum vardı ve sonunda kendi çözümümü oluşturmayı seçtim. Kullanmadan düzenli ifade motoru:

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

Önceki çözümlerin, bir başkası için önek olarak kullanılan kelimenin cevabı olmadığını fark edebilirsiniz. Örneğinizi kullanmak için:

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

Yukarıdaki örneklerin ile hem $ave $biçerdiği $c, ancak işlevi yalnızca söylemek isteyebilir $aiçeren $c.

Bir dizeden strstr () ve stristr () kullanarak bir kelimenin bulunmasını bulmak için başka bir seçenek de şöyledir:

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

substr_countSonucun kullanılıp kullanılmadığını kontrol eden birçok yanıt >0. Ancak ififade, sıfırı yanlışla aynı kabul ettiğinden, bu denetimi ve yazmayı doğrudan önleyebilirsiniz:

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

Mevcut olup olmadığını kontrol etmek için !operatörü ekleyin :

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

Üç farklı şekilde yapılabilir:

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

Kısa el versiyonu

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

Bir 'kelime' bulmak için, aslında başka bir kelimenin bir parçası olabilecek bir dizi harfin ortaya çıkmasından ziyade, aşağıdakiler iyi bir çözüm olacaktır.

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

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

Büyük / küçük harf duyarsız biçimi kullanmalısınız, bu nedenle girilen değer içerideyse smallveya capsönemli değilse .

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

Burada stripos buluntular heystack içinde iğne olmayan durumda (küçük / kapakları) göz önüne alındığında.

Çıkışlı PHPCode Örneği

Belki böyle bir şey kullanabilirsiniz:

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

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

preg_match()Yalnızca bir dizenin başka bir dizede bulunup bulunmadığını kontrol etmek istiyorsanız kullanmayın . Daha hızlı olacağı için strpos()veya strstr()yerine kullanın . ( http://in2.php.net/preg_match )

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

Dizenin birkaç spesifik kelime içerip içermediğini kontrol etmek istiyorsanız, şunları yapabilirsiniz:

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

Bu, örneğin e-posta gönderirken spam'ı önlemek için kullanışlıdır.

Strpos işlevi iyi çalışır, ancak case-insensitivebir paragrafta bir sözcüğü denetlemek istiyorsanız, striposişlevini kullanabilirsiniz PHP.

Örneğin,

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

Bir dizede büyük / küçük harfe duyarlı olmayan bir alt dizenin ilk oluşumunun konumunu bulun.

Sözcük dizede yoksa, yanlış döndürür, başka bir deyişle kelimenin konumunu döndürür.

Özdeş / özdeş olmayan işleçler kullanmanız gerekir, çünkü strpos dizin değeri olarak 0 döndürebilir. Üçlü operatörleri seviyorsanız, aşağıdakileri kullanmayı düşünün (itiraf edeceğim biraz geriye doğru görünüyor):

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

Dizenin belirli kelimeler içerip içermediğini kontrol ettiniz mi?

Bu, dizenin kelimelere çözülmesi gerektiği anlamına gelir (aşağıdaki nota bakın).

Bunu yapmanın ve ayırıcıları belirtmenin bir yolu preg_split( doc ) kullanmaktır:

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

?>

Bir koşu verir

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

Not: Burada her sembol dizisi için bir kelime kastetmiyoruz.

Kelimenin pratik bir tanımı, PCRE düzenli ifade motorunun, kelimelerin sadece sözcük karakterlerinden oluşan alt dizeler olduğu ve sözcük olmayan karakterlerle ayrıldığı anlamındadır.

Bir "kelime" karakteri herhangi bir harf ya da rakam ya da alt çizgi karakteri, yani Perl kelimesinin bir parçası olabilecek herhangi bir karakterdir. Harflerin ve rakamların tanımı PCRE'nin karakter tabloları tarafından kontrol edilir ve yerel ayara özel eşleştirme gerçekleşiyorsa değişebilir (..)

Belirli bir dize için başka bir çözüm:

$subject = 'How are you?';
$pattern = '/are/';
preg_match($pattern, $subject, $match);
if ($match[0] == 'are') {
    echo true;
}

Ayrıca strpos()işlevi kullanabilirsiniz .