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



Answers

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

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

$a = 'How are you?';

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

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

Question

विचार करें:

$a = 'How are you?';

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

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




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)



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

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



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

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




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

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



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

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

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




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



आपको केस असंवेदनशील प्रारूप का उपयोग करना चाहिए, इसलिए यदि दर्ज मूल्य 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 फ़ंक्शन 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 समान प्रकार हैं - यानी दोनों स्ट्रिंग हैं या दोनों पूर्णांक हैं।




एक और विकल्प strstr() फ़ंक्शन का उपयोग करना है। कुछ इस तरह:

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

ध्यान दें: स्ट्रस्ट्र () फ़ंक्शन केस-संवेदी है। एक केस-असंवेदनशील खोज के लिए, stristr() फ़ंक्शन का उपयोग करें।




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

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



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

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

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



अगर परिणाम >0 है तो substr_count चेक का उपयोग करने वाले बहुत सारे उत्तर substr_count । लेकिन चूंकि if कथन शून्य को समान मानता है, तो आप उस चेक से बच सकते हैं और सीधे लिख सकते हैं:

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

यह जांचने के लिए कि मौजूद नहीं है , जोड़ें ! ऑपरेटर:

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



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

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



Related



Tags

php php   string