නූලක නිශ්චිත වචනයක් තිබේදැයි පරීක්ෂා කරන්නේ කෙසේද?

සලකා බලන්න:

$a = 'How are you?';

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

ඉහත කේතය මා සතුව ඇතැයි සිතමු, ප්‍රකාශය ලිවීමට නිවැරදි ක්‍රමය if ($a contains 'are')කුමක්ද?

strpos()එක් නූලක් තවත් එකක් තුළ සිදුවීම සොයා ගැනීමට භාවිතා කරන ශ්‍රිතය ඔබට භාවිතා කළ හැකිය :

$a = 'How are you?';

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

භාවිතය !== falseහිතාමතා බව සලකන්න ( අපේක්ෂිත ප්‍රති result ලය ද != falseනොලැබේ === true); strpos()එක්කෝ පිදුරු නූල් වලින් ඉඳිකටු නූල් ආරම්භ වන ඕෆ්සෙට් එක හෝ falseඉඳිකටුව සොයාගත නොහැකි නම් බූලියන් යවයි . 0 වලංගු ඕෆ්සෙට් එකක් වන අතර 0 "ෆෝල්සි" බැවින් අපට වැනි සරල ඉදිකිරීම් භාවිතා කළ නොහැක !strpos($a, 'are').

ඔබට නිත්‍ය ප්‍රකාශන භාවිතා කළ හැකිය, strposඅනෙක් පරිශීලකයින් සඳහන් කළ පරිදි වචන ගැලපීම සඳහා එය වඩා හොඳය , ගාස්තු, රැකවරණය, බැල්ම වැනි නූල් සඳහාද එය සත්‍ය වනු ඇත. වචන සීමා මායිම් භාවිතා කිරීමෙන් මෙය සාමාන්‍ය ප්‍රකාශනයෙන් වළක්වා ගත හැකිය.

සඳහා සරල ගැලපීමක් මේ වගේ දෙයක් විය හැකිය:

$a = 'How are you?';

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

කාර්ය සාධනය පැත්තෙන්, strposඑය තුන් ගුණයක් වේගවත් වන අතර මතක තබා ගන්න, මම එකවර මිලියනයක් කළ විට, එය preg_matchනිම කිරීමට තත්පර 1.5 ක් strposගත වූ අතර තත්පර 0.5 ක් ගත විය.

සංස්කරණය කරන්න: වචනයෙන් වචනයෙන් පමණක් නොව, නූලෙහි ඕනෑම කොටසක් සෙවීම සඳහා, වැනි සාමාන්‍ය ප්‍රකාශනයක් භාවිතා කිරීමට මම නිර්දේශ කරමි

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

මෙම iඔබ එය තැබිය හැක, ඒ අවශ්ය නැති නම් පහත ප්රකාශන අවසානයේ සාමාන්ය ලෙස, නඩුව-අසංවේදී විය වෙනස් වෙනවා.

දැන්, සමහර අවස්ථාවල මෙය තරමක් ගැටලු සහගත විය හැකිය $ සෙවුම් නූල කිසිදු ආකාරයකින් සනීපාරක්ෂාව කර නොමැති නිසා, මම අදහස් කළේ, එය සමහර අවස්ථාවලදී චෙක්පත සම්මත නොකරනු $searchඇත, පරිශීලක ආදානයක් ලෙස ඔවුන්ට හැසිරවිය හැකි නූලක් එක් කළ හැකිය. වෙනස් නිත්‍ය ප්‍රකාශනයක් ...

එසේම, විවිධ නිත්‍ය ප්‍රකාශනවල පැහැදිලි කිරීම් පරීක්ෂා කිරීම සහ දැකීම සඳහා විශිෂ්ට මෙවලමක් මෙන්න Regex101 හි මෙන්න

ක්‍රියාකාරීත්ව කට්ටල දෙකම තනි බහු කාර්ය ශ්‍රිතයකට ඒකාබද්ධ කිරීම සඳහා (තෝරා ගත හැකි සිද්ධි සංවේදීතාව ඇතුළුව), ඔබට මෙවැනි දෙයක් භාවිතා කළ හැකිය:

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

මෙන්න මේ වගේ අවස්ථාවන්හිදී ප්‍රයෝජනවත් වන කුඩා උපයෝගිතා ශ්‍රිතයක්

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

මෙම පිළිතුරු වලින් බොහොමයක් ඔබේ නූලෙහි උපස්ථරයක් දිස්වන්නේ දැයි ඔබට කියනු ඇත, නමුත් සාමාන්‍යයෙන් ඔබ විශේෂිත වචනයක් සොයන්නේ නම් එය ඔබට අවශ්‍ය නොවේ, උපස්ථරයක් නොවේ .

මොකක්ද වෙනස? වෙනත් වචන වලින් උපසිරැසි දිස්විය හැකිය:

• "ප්‍රදේශය" ආරම්භයේ "වේ"
• "හාවා" අවසානයේ "වේ"
• "ගාස්තු" මැද "වේ"

මෙය අවම කිරීම සඳහා එක් ක්‍රමයක් වනුයේ වචන මායිම් ( \b) සමඟ නිත්‍ය ප්‍රකාශනයක් භාවිතා කිරීමයි :

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

මෙම ක්‍රමයට ඉහත සඳහන් කළ ව්‍යාජ ධනාත්මක කරුණු නොමැත, නමුත් එයට එයටම ආවේණික වූ අවස්ථා තිබේ. වචනය හතරේ පහර (වදන් නොවන අක්ෂර මත ගැලපෙන \Wනොවන බව ඕනෑම දෙයක් වනු ඇති,) a-z, A-Z, 0-9, හෝ _. ඒ කියන්නේ ඉලක්කම් සහ යටි ඉරි ලකුණු වචන අක්‍ෂර ලෙස ගණන් ගනු ඇති අතර මෙවැනි අවස්ථා අසාර්ථක වනු ඇත:

• "ඔබ සිතන්නේ කුමක්ද?"
• "ලොල් යූ ඩුන්නෝ වට් 4" හි "තිබේද"?

ඔබට මීට වඩා නිවැරදි යමක් අවශ්‍ය නම්, ඔබට ඉංග්‍රීසි භාෂා සින්ටැක්ස් විග්‍රහ කිරීම ආරම්භ කළ යුතු අතර, එය පණුවන් විශාල ප්‍රමාණයක් (සහ සින්ටැක්ස් නිසි ලෙස භාවිතා කිරීම උපකල්පනය කරයි, කෙසේ වෙතත්, එය සැමවිටම ලබා දී නැත).

නූලක වෙනත් නූලක් තිබේද යන්න තීරණය කිරීම සඳහා ඔබට 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";
}

?>

අවවාදයයි:

ඔබ සොයන ඉඳිකටුවක් පිදුරු මිටියේ ආරම්භයේ තිබේ නම් එය 0 වන ස්ථානයට පැමිණෙනු ==ඇත, ඔබ වැඩ නොකරන සංසන්දනයක් කළහොත් ඔබට එය කිරීමට අවශ්‍ය වනු ඇත===

ඒ ==සංඥා වමට විචල්ය / ප්රකාශනය / නිරන්තර යන්න සංසන්දනය හා පරීක්ෂණ විචල්ය / ප්රකාශනය / දකුණට නියතය ලෙස එම අගය කර ඇත.

ඒ ===ලකුණක් විචල්ය දෙකක් / expresions / නියත සමාන දැයි අතර සැසඳීමකි ANDඑනම් දෙකම නූල් හෝ දෙකම නිඛිල - එකම වර්ගයේ ඇත.

බලන්න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.";
    }
?>

භාවිතා කිරීම strstr()හෝ stristr()ඔබේ සෙවුම සංවේදී නොවිය යුතු නම් තවත් විකල්පයක් වනු ඇත.

SamGoody සහ Lego Stormtroopr අදහස් දැක්වීමට සම වයසේ මිතුරන්.

බහුවිධ වචනවල සමීපත්වය / අදාළත්වය මත පදනම්ව සෙවුම් ප්‍රති results ල ශ්‍රේණිගත කිරීම සඳහා ඔබ PHP ඇල්ගොරිතමයක් සොයන්නේ නම්, මෙහි පැමිණෙන්නේ PHP සමඟ පමණක් සෙවුම් ප්‍රති results ල ජනනය කිරීමේ ඉක්මන් හා පහසු ක්‍රමයක්:

, හෝ strpos(), වැනි වෙනත් බූලියන් සෙවුම් ක්‍රම සමඟ ගැටළුpreg_match()strstr()stristr()

1. වචන කිහිපයක් සෙවිය නොහැක
2. ප්‍රති results ල නිරුපද්‍රිතව ඇත

දෛශික අභ්‍යවකාශ ආකෘතිය සහ ටීඑෆ්-අයිඩීඑෆ් (කාලීන සංඛ්‍යාතය-ප්‍රතිලෝම ලේඛන සංඛ්‍යාතය) මත පදනම් වූ PHP ක්‍රමය :

එය දුෂ්කර යැයි පෙනෙන නමුත් පුදුම හිතෙන තරම් පහසුය.

අපට වචන කිහිපයකින් වචන සෙවීමට අවශ්‍ය නම් මූලික ගැටළුව වන්නේ අප ඒ සෑම එකක් සඳහාම බරක් පවරන්නේ කෙසේද යන්නයි.

සමස්ථයක් ලෙස වචන කෙතරම් නිරූපණය කරන්නේද යන්න මත පදනම්ව අපට වචන මාලාවකින් බර කිරා ගත හැකි නම්, අපගේ ප්‍රති results ල විමසුමට වඩාත්ම ගැලපෙන ඒවා මඟින් ඇණවුම් කළ හැකිය.

දෛශික අභ්‍යවකාශ ආකෘතියේ අදහස මෙයයි, 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;
}

CASE 1

$query = 'are';

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

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

ප්‍රති ES ලය

Array
(
    [1] => 0.52832083357372
)

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

ප්රතිපල

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

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

ප්රතිපල

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

කළ යුතු වැඩි දියුණු ඕන තරම් තිබෙනවා නමුත් ආකෘතිය වැනි වීජ operators නොමැති ස්වාභාවික විමසුම්, හොඳ ප්රතිඵල ලබා මඟින් ලබා දේ strpos(), preg_match(), strstr()හෝ stristr().

නෝටා බෙනේ

වචන සෙවීමට පෙර අතිරික්තය විකල්පයෙන් ඉවත් කිරීම

• එමඟින් දර්ශක ප්‍රමාණය අඩු කරන අතර එහි ප්‍රති storage ලයක් ලෙස ගබඩා අවශ්‍යතාවය අඩු වේ

• අඩු තැටිය I / O.

• වේගවත් සුචිගත කිරීම සහ එහි ප්‍රති fast ලයක් ලෙස වේගවත් සෙවීමක්.

1. සාමාන්‍යකරණය

• සියලුම පෙළ කුඩා අකුරට පරිවර්තනය කරන්න

2. නැවතුම් වචන ඉවත් කිරීම

• සත්‍ය අර්ථයක් නොමැති වචන වලින් වචන ඉවත් කරන්න ('සහ', 'හෝ', 'ද', 'සඳහා' ආදිය)

3. ශබ්දකෝෂ ආදේශනය

• සමාන හෝ සමාන අර්ථයක් ඇති වචන වෙනත් අය සමඟ ආදේශ කරන්න. (උදා: 'කුසගින්නෙන්' සහ 'කුසගින්නෙන් පෙළෙන අය' කුසගින්නෙන් ආදේශ කරන්න)

• වචනවල අත්‍යවශ්‍ය අරුත තවදුරටත් අඩු කිරීම සඳහා තවදුරටත් ඇල්ගොරිතම මිනුම් (හිමබෝල) සිදු කළ හැකිය.

• වර්ණ නම් ඒවායේ ෂඩාස්රාකාර සමානකම් සමඟ ආදේශ කිරීම

• නිරවද්‍යතාවය අඩු කිරීමෙන් සංඛ්‍යාත්මක අගයන් අඩු කිරීම පෙළ සාමාන්‍යකරණය කිරීමේ වෙනත් ක්‍රම වේ.

සම්පත්

• http://linuxgazette.net/164/sephton.html
• http://snowball.tartarus.org/
• MySQL Fulltext සෙවුම් ලකුණු පැහැදිලි කරන ලදි
• 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/

භාවිතා කරන්න නඩුව-insensitve ගැලපෙන භාවිතා stripos():

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

ඔබට "වැරදි" සහ "සත්‍ය" ගැටළුව මඟහරවා ගැනීමට අවශ්‍ය නම්, ඔබට substr_count භාවිතා කළ හැකිය:

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

එය ස්ට්රෝපෝස් වලට වඩා ටිකක් මන්දගාමී නමුත් එය සංසන්දනය කිරීමේ ගැටළු මඟහරවා ගනී.

තවත් විකල්පයක් වන්නේ strstr () ශ්‍රිතය භාවිතා කිරීමයි . වැනි දෙයක්:

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

සැලකිල්ලට ගත යුතු කරුණ: strstr () ශ්‍රිතය සිද්ධි සංවේදී වේ. සිද්ධි-සංවේදී නොවන සෙවීමක් සඳහා, stristr () ශ්‍රිතය භාවිතා කරන්න.

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

මම ටිකක් භාවිතා බව මෙහි පිළිතුරු පිළිනොගන්නා බව පැහැදීමට ඉන්නේ strpos, strstrසහ ඒ හා සමාන කාර්යයන් සඳහන් Multibyte සංගීත කාර්යයන් මෙතෙක් (2015-05-08).

මූලික වශයෙන්, ඔබ කරන්නේ නම්, සමහර භාෂා චරිත විශේෂිත සමග කරදර සොයා වචන සහිත ආදිය ජර්මන්, ප්රංශ, පෘතුගීසි, ස්පාඤ්ඤ, ලෙස, (උදා: A , E , O , C , º , n ), ඔබ ද්විවිවාහ කිරීමට ඔබට අවශ්ය විය හැක සමඟ කාර්යයන් mb_. එබැවින්, පිළිගත් පිළිතුර ඒ වෙනුවට භාවිතා කරනු ඇත mb_strposහෝ mb_stripos(සිද්ධි-සංවේදී නොවන ගැලපීම සඳහා):

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

ඔබගේ සියලු දත්ත යූටීඑෆ් -8 හි 100% ක් බව ඔබට සහතික කළ නොහැකි නම් , ඔබට එය භාවිතා කිරීමට අවශ්‍ය විය හැකියmb_ කාර්යයන් .

ජොයෙල් ස්පොල්ස්කි විසින් රචිත යුනිකෝඩ් සහ අක්‍ෂර කට්ටල (නිදහසට කරුණක් නැත!) ගැන නිරපේක්ෂ අවම වශයෙන් සෑම මෘදුකාංග සංවර්ධකයෙක්ම දැනගත යුතු හොඳ ලිපියක් .

PHP හි, නූලක කිසියම් උපස්ථරයක් තිබේදැයි තහවුරු කර ගත හැකි හොඳම ක්‍රමය නම්, මේ හා සමාන සරල උපකාරක ශ්‍රිතයක් භාවිතා කිරීමයි:

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

පැහැදිලි කිරීම:

• strpos නූලක සිද්ධි සංවේදී උපස්ථරයක පළමු සිදුවීමේ පිහිටීම සොයා ගනී.
• stripos නූලක අක්ෂර-සංවේදී නොවන උපස්ථරයක පළමු සිදුවීමේ පිහිටීම සොයා ගනී.
• myFunction($haystack, $needle) === FALSE ? FALSE : TRUEmyFunctionසෑම විටම බූලියන් ආපසු ලබා දෙන බවට සහතික වන අතර උපස්ථරයේ දර්ශකය 0 වන විට අනපේක්ෂිත හැසිරීම නිවැරදි කරයි.
• $caseSensitive ? A : Bඅගය මත පදනම්ව strposහෝ striposවැඩ කිරීමට තෝරා ගනී $caseSensitive.

ප්‍රතිදානය:

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)

පහත ශ්‍රිතය ද ක්‍රියා කරන අතර වෙනත් කිසිදු ශ්‍රිතයක් මත රඳා නොපවතී; එය භාවිතා කරන්නේ ස්වදේශීය PHP නූල් හැසිරවීම පමණි. පුද්ගලිකව, මම මෙය නිර්දේශ නොකරමි, නමුත් එය ක්‍රියාත්මක වන ආකාරය ඔබට දැක ගත හැකිය:

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

පරීක්ෂණය:

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ශ්‍රිතය භාවිතා කළ හැකිය :

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

if ($flag){

    echo "true";
}

ඉන්බිල්ට් ශ්‍රිතයක් භාවිතා නොකර:

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

මට මේ සම්බන්ධයෙන් යම් කරදරයක් ඇති වූ අතර අවසානයේ මම මගේම විසඳුමක් නිර්මාණය කිරීමට තීරණය කළෙමි. සාමාන්‍ය ප්‍රකාශන එන්ජිම භාවිතා නොකර :

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

පෙර විසඳුම් වෙනත් වචනයක් සඳහා උපසර්ගයක් ලෙස භාවිතා කිරීම සඳහා පිළිතුරක් නොවන බව ඔබට පෙනෙනු ඇත. ඔබේ උදාහරණය භාවිතා කිරීම සඳහා:

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

ඉහත සාම්පල සමඟ, දෙකම $aසහ $bඅඩංගු වේ $c, නමුත් ඔබේ ක්‍රියාකාරිත්වය ඔබට පමණක් $aඅඩංගු බව පැවසීමට ඔබට අවශ්‍ය විය හැකිය $c.

Ststrr () සහ stristr () භාවිතා කරමින් නූලකින් වචනයක් ඇතිවීම සොයා ගැනීමට තවත් විකල්පයක් පහත පරිදි වේ:

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

ප්‍රති substr_countresult ලය නම් චෙක්පත් භාවිතා කරන පිළිතුරු ගොඩක් >0. නමුත් එම ifප්‍රකාශය ශුන්‍යය අසත්‍යයක් ලෙස සලකන බැවින් , ඔබට එම චෙක්පත මඟ හැර කෙලින්ම ලිවිය හැකිය:

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

තිබේදැයි පරීක්ෂා කිරීමට නොමැති කිරීමට, !ක්‍රියාකරු එක් කරන්න :

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

එය ආකාර තුනකින් කළ හැකිය:

 $a = 'How are you?';

1- ස්ට්‍රිස්ටර් ()

 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
 }

කෙටි අත් අනුවාදය

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

වෙනත් වචනයක කොටසක් විය හැකි අකුරු මාලාවක් ඇතිවීමට වඩා 'වචනයක්' සොයා ගැනීම සඳහා පහත සඳහන් කරුණු හොඳ විසඳුමක් වනු ඇත.

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

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

ඔබ කේස් ඉන්සෙන්සිටිව් ආකෘතිය භාවිතා කළ යුතුය, එබැවින් ඇතුළත් කළ අගය තිබේ නම් smallහෝ capsඑය වැදගත් නොවේ.

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

මෙහි (කුඩා / තොප්පි) සලකා බැලීමෙන් තොරව ස්ට්‍රිපෝස් විසින් ඉඳිකටුවක් සොයා ගනී .

ප්‍රතිදානය සහිත PHPCode නියැදිය

සමහර විට ඔබට මේ වගේ දෙයක් භාවිතා කළ හැකිය:

<?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()එක් නූලක් තවත් නූලක අඩංගු දැයි පරීක්ෂා කිරීමට ඔබට අවශ්‍ය නම් භාවිතා නොකරන්න . ඒවා වේගවත් වන බැවින් භාවිතා කරන්න strpos()හෝ strstr()ඒ වෙනුවට. ( http://in2.php.net/preg_match )

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

ඔබට නිශ්චිත වචන කිහිපයක් අඩංගු දැයි පරීක්ෂා කිරීමට අවශ්‍ය නම්, ඔබට මෙය කළ හැකිය:

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

උදාහරණයක් ලෙස ඊමේල් යැවීමේදී අයාචිත තැපැල් වළක්වා ගැනීමට මෙය ප්‍රයෝජනවත් වේ.

ස්ට්රෝපෝස් ශ්‍රිතය හොඳින් ක්‍රියාත්මක වේ, නමුත් ඔබට case-insensitiveඡේදයක වචනයක් පරික්ෂා කිරීමට අවශ්‍ය නම් එවිට ඔබට එහි striposක්‍රියාකාරිත්වය භාවිතා කළ හැකියPHP .

උදාහරණයක් වශයෙන්,

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

නූලක අක්ෂර-සංවේදී උපස්ථරයක පළමු සිදුවීමේ පිහිටීම සොයා ගන්න.

වචනය වචනයේ පරිසමාප්ත අර්ථයෙන්ම නොපවතින විට එය අසත්‍යයක් වනු ඇත.

ඔබට සමාන / සමාන නොවන ක්‍රියාකරුවන් භාවිතා කිරීමට අවශ්‍ය වන්නේ strpos හි දර්ශක අගය ලෙස 0 ආපසු ලබා දිය හැකි බැවිනි. ඔබ තෘතීය ක්‍රියාකරුවන්ට කැමති නම්, පහත සඳහන් දෑ භාවිතා කිරීම ගැන සලකා බලන්න (මඳක් පසුපසට පෙනෙන බව මම පිළිගනිමි):

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

නූලට නිශ්චිත වචන තිබේදැයි පරීක්ෂා කරන්න?

මෙයින් අදහස් කරන්නේ නූල වචන වලට විසඳිය යුතු බවයි (පහත සටහන බලන්න).

මෙය කිරීමට සහ බෙදුම්කරුවන් නියම කිරීමට එක් ක්‍රමයක් වන්නේ 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');

?>

ධාවනය ලබා දෙයි

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

සටහන: මෙහිදී අපි සංකේතවල සෑම අනුක්‍රමයක් සඳහාම වචනයක් අදහස් නොකරමු.

වචනයේ ප්‍රායෝගික අර්ථ දැක්වීම අර්ථයෙන් PCRE නිත්‍ය ප්‍රකාශන එන්ජිම වන අතර, වචන යනු වචන අක්ෂර වලින් පමණක් සමන්විත වන අතර වචන නොවන අක්ෂර වලින් වෙන් කරනු ලැබේ.

“වචනයක්” යනු ඕනෑම අකුරක් හෝ ඉලක්කම් හෝ අවධාරනය කරන අක්‍ෂරයකි, එනම් පර්ල් “වචනයක” කොටසක් විය හැකි ඕනෑම අක්‍ෂරයකි. අකුරු සහ ඉලක්කම් වල අර්ථ දැක්වීම PCRE හි අක්ෂර වගු මගින් පාලනය වන අතර, ස්ථානීය-විශේෂිත ගැලපීම් සිදුවන්නේ නම් වෙනස් විය හැකිය (..)

විශේෂිත නූලක් සඳහා තවත් විසඳුමක්:

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

ඔබට strpos()ශ්‍රිතය ද භාවිතා කළ හැකිය .