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




string substring (20)

विचार करें:

$a = 'How are you?';

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

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

https://code.i-harness.com


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

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

ऐसा करने का तरीका और विभाजक निर्दिष्ट करने के लिए 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 में, यह सत्यापित करने का सबसे अच्छा तरीका है कि स्ट्रिंग में एक निश्चित सबस्ट्रिंग है, इस तरह एक सरल सहायक फ़ंक्शन का उपयोग करना है:

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)

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

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

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

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

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

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

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

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

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

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

$a = 'How are you?';

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

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


आपको समान / समान समान ऑपरेटरों का उपयोग करने की आवश्यकता नहीं है क्योंकि स्ट्रॉप्स 0 को इंडेक्स वैल्यू के रूप में वापस कर सकता है। यदि आप टर्नरी ऑपरेटरों को पसंद करते हैं, तो निम्न का उपयोग करने पर विचार करें (थोड़ा पीछे लगता है मैं स्वीकार करूंगा):

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

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

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

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


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

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


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

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

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

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

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


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

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

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


यह तीन अलग-अलग तरीकों से किया जा सकता है:

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

स्ट्रॉप्स फ़ंक्शन ठीक काम करता है, लेकिन यदि आप 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'

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

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







string-matching