php - मैं कैसे जांचूं कि एक स्ट्रिंग में एक विशिष्ट शब्द है या नहीं?




string substring contains string-matching (25)

विचार करें:

$a = 'How are you?';

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

मान लीजिए मेरे पास उपरोक्त कोड है, if ($a contains 'are') कथन लिखने का सही तरीका क्या है if ($a contains 'are') ?


Answers

लघु हाथ संस्करण

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

स्ट्रॉप्स फ़ंक्शन ठीक काम करता है, लेकिन यदि आप case-insensitiveपैराग्राफ में किसी शब्द की जांच करना चाहते हैं तो आप striposफ़ंक्शन का उपयोग कर सकते हैं PHP

उदाहरण के लिए,

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

एक स्ट्रिंग में केस-असंवेदनशील सबस्ट्रिंग की पहली घटना की स्थिति पाएं।

यदि शब्द स्ट्रिंग में मौजूद नहीं है तो यह झूठी वापसी करेगा और यह शब्द की स्थिति वापस कर देगा।


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

मैं थोड़ा प्रभावित हूं कि यहां कोई जवाब नहीं है जो strpos , strstr और इसी तरह के कार्यों का उपयोग करता है, अभी तक मल्टीबाइट स्ट्रिंग फ़ंक्शंस का उल्लेख किया गया है (2015-05-08)।

असल में, अगर आपको जर्मन, फ़्रेंच, पुर्तगाली, स्पैनिश इत्यादि जैसी कुछ भाषाओं के विशिष्ट शब्दों के साथ शब्दों को खोजने में परेशानी हो रही है (उदाहरण: ä , é , ô , ç , º , ñ ), तो आप पहले से चाह सकते हैं mb_ साथ mb_ । इसलिए, स्वीकृत उत्तर mb_strpos या mb_stripos (केस-असंवेदनशील मिलान के लिए) का उपयोग करेगा:

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

यदि आप गारंटी नहीं दे सकते कि यूटीएफ -8 में आपका सभी डेटा 100% है , तो आप mb_ फ़ंक्शंस का उपयोग करना चाह सकते हैं।

यह समझने के लिए एक अच्छा लेख है कि पूर्ण न्यूनतम सॉफ्टवेयर डेवलपर बिल्कुल क्यों है , जोएल स्पॉस्की द्वारा यूनिकोड और कैरेक्टर सेट्स (कोई बहाना नहीं!) के बारे में सकारात्मक रूप से जानना चाहिए


यह निर्धारित करने के लिए कि किसी स्ट्रिंग में कोई अन्य स्ट्रिंग है या नहीं, आप 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 लौटाएगी, अगर आप एक == तुलना करते हैं जो काम नहीं करेगा, तो आपको एक ===

== संकेत एक तुलना है और परीक्षण करता है कि बाईं ओर परिवर्तनीय / अभिव्यक्ति / स्थिरांक वैरिएबल / अभिव्यक्ति / दाईं ओर स्थिर के समान मान है।

=== संकेत यह देखने के लिए एक तुलना है कि दो चर / एक्सपेशंस / स्थिरांक बराबर हैं 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.";
    }
?>

मुझे इसके साथ कुछ परेशानी थी, और आखिर में मैंने अपना खुद का समाधान बनाना चुना। नियमित अभिव्यक्ति इंजन का उपयोग किए बिना:

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


stripos() का उपयोग कर केस-असंवेदनशील मिलान का उपयोग करें:

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

stristr() strstr() या stristr() का उपयोग करना यदि आपकी खोज केस असंवेदनशील हो तो दूसरा विकल्प होगा।


preg_match() प्रयोग न करें अगर आप केवल यह जांचना चाहते हैं कि एक स्ट्रिंग किसी अन्य स्ट्रिंग में निहित है या नहीं। इसके बजाय strpos() या strstr() उपयोग करें क्योंकि वे तेज़ होंगे। ( http://in2.php.net/preg_match )

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

यदि आप जांचना चाहते हैं कि स्ट्रिंग में कई विशिष्ट शब्द हैं, तो आप यह कर सकते हैं:

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

उदाहरण के लिए ईमेल भेजते समय स्पैम से बचने के लिए यह उपयोगी है।


नीचे दिया गया कार्य भी काम करता है और किसी भी अन्य समारोह पर निर्भर नहीं करता है; यह केवल देशी 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 

शायद आप इस तरह कुछ इस्तेमाल कर सकते हैं:

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

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

SamGoody और लेगो Stormtroopr टिप्पणियों के लिए सहकर्मी।

यदि आप कई शब्दों की निकटता / प्रासंगिकता के आधार पर खोज परिणामों को रैंक करने के लिए PHP एल्गोरिदम खोज रहे हैं तो यहां केवल PHP के साथ खोज परिणाम उत्पन्न करने का एक त्वरित और आसान तरीका आता है:

अन्य बूलियन खोज विधियों जैसे strpos() , preg_match() , stristr() या stristr()

  1. एकाधिक शब्दों की खोज नहीं कर सकता
  2. परिणाम असंबद्ध हैं

वेक्टर स्पेस मॉडल और टीएफ-आईडीएफ (टर्म आवृत्ति-उलटा दस्तावेज़ आवृत्ति) पर आधारित PHP विधि :

यह मुश्किल लगता है लेकिन आश्चर्यजनक रूप से आसान है।

यदि हम स्ट्रिंग में एकाधिक शब्दों को खोजना चाहते हैं तो मूल समस्या यह है कि हम उनमें से प्रत्येक को वजन कैसे देते हैं?

यदि हम पूरी तरह से स्ट्रिंग के प्रतिनिधि के आधार पर स्ट्रिंग में शर्तों को वज़न दे सकते हैं, तो हम अपने परिणामों को उन लोगों द्वारा ऑर्डर कर सकते हैं जो क्वेरी से सबसे अच्छे मेल खाते हैं।

यह वेक्टर स्पेस मॉडल का विचार है, एसक्यूएल पूर्ण-पाठ खोज कैसे काम करता है:

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

मामला एक

$query = 'are';

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

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

परिणाम

Array
(
    [1] => 0.52832083357372
)

मामला 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
)

मामला 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
)

बहुत सारे सुधार किए जा सकते हैं लेकिन मॉडल प्राकृतिक प्रश्नों से अच्छे नतीजे पाने का एक तरीका प्रदान करता है, जिसमें strpos() , preg_match() , stristr() या stristr() जैसे बुलियन ऑपरेटर नहीं होते हैं।

नोटा बेन

शब्दों को खोजने से पहले वैकल्पिक रूप से अनावश्यकता को खत्म करना

  • जिससे सूचकांक आकार कम हो जाता है और जिसके परिणामस्वरूप कम संग्रहण आवश्यकता होती है

  • कम डिस्क I / O

  • तेजी से अनुक्रमण और एक परिणामस्वरूप तेजी से खोज।

1. सामान्यीकरण

  • सभी पाठ को कम मामले में कनवर्ट करें

2. रोकथाम उन्मूलन

  • उस पाठ से शब्दों को हटा दें जिसमें कोई वास्तविक अर्थ नहीं है (जैसे 'और', 'या', 'the', 'for', आदि)

3. शब्दकोश प्रतिस्थापन

  • उन शब्दों के साथ शब्दों को बदलें जिनके समान या समान अर्थ हैं। (उदा: 'भूख' और 'भुखमरी' के उदाहरणों को 'भूख' के साथ बदलें)

  • आगे के एल्गोरिदमिक उपायों (स्नोबॉल) को उनके आवश्यक अर्थों को शब्दों को कम करने के लिए किया जा सकता है।

  • उनके हेक्साडेसिमल समकक्षों के साथ रंगीन नामों का प्रतिस्थापन

  • सटीकता को कम करके संख्यात्मक मूल्यों में कमी पाठ को सामान्य करने के अन्य तरीकों हैं।

संसाधन


हालांकि इनमें से अधिकतर उत्तर आपको बताएंगे कि क्या आपकी स्ट्रिंग में कोई सबस्ट्रिंग दिखाई देता है, आमतौर पर यह नहीं होता कि आप क्या चाहते हैं यदि आप किसी विशेष शब्द की तलाश में हैं , न कि सबस्ट्रिंग

क्या फर्क पड़ता है? सबस्ट्रिंग्स दूसरे शब्दों के भीतर प्रकट हो सकते हैं:

  • "क्षेत्र" की शुरुआत में "हैं"
  • "हरे" के अंत में "हैं"
  • "किराया" के बीच में "हैं"

इसे कम करने का एक तरीका शब्द सीमाओं के साथ एक नियमित अभिव्यक्ति का उपयोग करना होगा ( \b ):

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

इस विधि में ऊपर वर्णित वही झूठे सकारात्मक नहीं हैं, लेकिन इसमें स्वयं के कुछ किनारे हैं। शब्द सीमाएं गैर-शब्द वर्णों ( \W ) पर मेल खाते हैं, जो कुछ भी होने जा रहे हैं जो az , AZ , 0-9 , या _ । इसका मतलब है कि अंकों और अंडरस्कोर को शब्द वर्णों के रूप में गिना जा रहा है और इस तरह के परिदृश्य विफल हो जाएंगे:

  • "क्या हैं" में "क्या _are_ आप सोच रहे हैं?"
  • "हैं" में "लॉल यू डुनो वोट वे 4 हैं?"

यदि आप इससे कुछ और सटीक चाहते हैं, तो आपको अंग्रेजी भाषा सिंटैक्स पार्सिंग करना शुरू करना होगा, और यह कीड़े का एक बड़ा बड़ा हिस्सा है (और वाक्यविन्यास का उचित उपयोग मानता है, वैसे भी, जो हमेशा दिया नहीं जाता है)।


यदि आप "झूठी" और "सत्य" समस्या से बचना चाहते हैं, तो आप substr_count का उपयोग कर सकते हैं:

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

यह स्ट्रॉप्स की तुलना में थोड़ा धीमा है लेकिन यह तुलना की समस्याओं से बचाता है।


अक्षरों की एक श्रृंखला की घटना के बजाय 'शब्द' खोजने के लिए, जो वास्तव में किसी अन्य शब्द का हिस्सा हो सकता है, निम्नलिखित एक अच्छा समाधान होगा।

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

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

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 : TRUE myFunction($haystack, $needle) === FALSE ? FALSE : TRUE यह सुनिश्चित करता है कि myFunction हमेशा एक बुलियन लौटाता है और अप्रत्याशित व्यवहार को ठीक करता है जब सबस्ट्रिंग की अनुक्रमणिका 0 होती है।
  • $caseSensitive ? A : B $caseSensitive ? A : B $caseSensitive के मूल्य के आधार पर, कार्य करने के लिए या तो stripos() या stripos() का चयन करता है।

आउटपुट:

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 = 'How are you?';

1- स्ट्रिस्टर ()

 if (strlen(stristr($a,"are"))>0) {
    echo "true"; // are Found
 } 

2- स्ट्रॉप्स ()

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

3- preg_match ()

 if( preg_match("are",$a) === 1) {
   echo "true"; // are Found
 }

नीचे दिए गए फ़ंक्शन के साथ एक स्ट्रिंग की जांच की जा सकती है:

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

यहां एक छोटा उपयोगिता फ़ंक्शन है जो इस तरह की स्थितियों में उपयोगी है

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

stristr() और stristr() का उपयोग कर स्ट्रिंग से किसी शब्द की घटना को खोजने का दूसरा विकल्प निम्न जैसा है:

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

आप नियमित अभिव्यक्तियों का उपयोग कर सकते हैं, यह अन्य उपयोगकर्ताओं द्वारा वर्णित स्ट्रॉप्स की तुलना में शब्द मिलान के लिए बेहतर है, यह किराया, देखभाल, घबराहट इत्यादि जैसे तारों के लिए भी सच होगा। यह शब्द सीमाओं का उपयोग करके नियमित अभिव्यक्ति में से बचा जा सकता है।

इसके लिए एक साधारण मैच कुछ ऐसा दिख सकता है:

$a = 'How are you?';

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

प्रदर्शन पक्ष पर, स्ट्रॉप्स लगभग तीन गुना तेजी से होता है और ध्यान में आता है, जब मैंने एक मिलियन की तुलना एक बार में की थी, तो इसे खत्म करने के लिए प्रीग मैच 1.5 सेकंड लग गए और स्ट्रॉप्स के लिए इसमें 0.5 सेकंड लग गए।


जांचें कि स्ट्रिंग में विशिष्ट शब्द हैं या नहीं?

इसका मतलब है कि स्ट्रिंग को शब्दों में हल किया जाना चाहिए (नीचे नोट देखें)।

ऐसा करने का तरीका और विभाजक निर्दिष्ट करने के लिए preg_split ( doc ) का उपयोग कर रहा है:

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

एक रन देता है

<?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 string substring contains string-matching