it-swarm.dev

Jak zjistím, zda řetězec obsahuje a slovo?

Zvážit:

$a = 'How are you?';

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

Předpokládejme, že mám výše uvedený kód, jaký je správný způsob psaní příkazu if ($a contains 'are')?

2666
Charles Yeung

Můžete použít funkci strpos() , která slouží k nalezení výskytu jednoho řetězce uvnitř jiného řetězce:

$a = 'How are you?';

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

Všimněte si, že použití !== false je úmyslné; strpos() vrací buď posun, při kterém řetězec jehly začíná v řetězci sena, nebo boolean false, pokud jehla není nalezena. Protože 0 je platný posun a 0 je "falsey", nemůžeme použít jednodušší konstrukce jako !strpos($a, 'are').

6129
codaddict

Dalo by se použít regulární výrazy, je lepší, kdyby Word ve srovnání s strpos, jak uvedli jiní uživatelé, se také vrátí true pro řetězce, jako je jízdné, péče, pohled, atd. Toto lze jednoduše vyhnout v regulárním výrazu pomocí hranic aplikace Word.

Jednoduchá shoda pro uživatele by mohla vypadat takto:

$a = 'How are you?';

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

Na stránce výkonu je strpos asi třikrát rychlejší a má na mysli, když jsem udělal jeden milion najednou, to trvalo preg_match 1,5 sekundy do konce a strpos trvalo 0,5 sekundy.

Edit: Abych mohl hledat jakoukoliv část řetězce, ne jen Word by Word, doporučil bych použít regulární výraz jako

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

i na konci regulárního výrazu mění regulární výraz tak, aby nerozlišoval velká a malá písmena, pokud to nechcete, můžete jej nechat.

Nyní to může být v některých případech poměrně problematické, protože řetězec $ search není v žádném případě dezinfikován, to znamená, že v některých případech nemusí projít kontrolou, jako by $search byl vstup uživatele, který může přidat nějaký řetězec, který by se mohl chovat jako nějaký jiný regulární výraz ...

Také zde je skvělý nástroj pro testování a zobrazování vysvětlení různých regulárních výrazů Regex101

Chcete-li zkombinovat obě sady funkcí do jedné víceúčelové funkce (včetně volby rozlišitelné velikosti písmen), můžete použít něco takového:

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

Zde je malá užitková funkce, která je užitečná v takovýchto situacích

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

Zatímco většina z těchto odpovědí vám řekne, zda se ve vašem řetězci objeví podřetězec, obvykle to není to, co chcete, pokud hledáte konkrétní Word , a nikoli podřetězec .

Jaký je v tom rozdíl? Podtržení se může objevit v jiných slovech:

  • "Jsou" na začátku "oblasti"
  • "Jsou" na konci "zajíce"
  • "Jsou" uprostřed "jízdného"

Jedním ze způsobů, jak toto zmírnit, by bylo použít regulární výraz spojený s hranicemi slov (\b):

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

Tato metoda nemá stejné falešné poplachy uvedené výše, ale má své vlastní případy Edge. Hranice slov se shodují s ne-slovními znaky (\W), což bude cokoliv, co není a-z, A-Z, 0-9 nebo _. Znamená to, že číslice a podtržítka budou počítány jako znaky aplikace Word a scénáře, jako je toto, se nezdaří:

  • "Jsou" v "Co si myslíš?"
  • "Jsou" v "lol u dunno wut ty are4?"

Pokud chcete něco přesnějšího než toto, budete muset začít dělat syntaktickou syntaktickou analýzu anglického jazyka, a to je dost velká červí červi (a předpokládá správné použití syntaxe stejně, což není vždy dané).

128
FtDRbwLXw6

Chcete-li zjistit, zda řetězec obsahuje jiný řetězec, můžete použít funkci 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";
}

?>

POZOR:

Pokud je jehla, kterou hledáte, na začátku kupky sena, vrátí pozici 0, pokud provedete porovnání ==, které nebude fungovat, budete muset udělat ===

Znaménko == je porovnání a testy, zda proměnná/výraz/konstanta vlevo má stejnou hodnotu jako proměnná/výraz/konstanta vpravo.

Znaménko === je porovnání, které zjistí, zda dvě proměnné/výrazy/konstanty jsou rovny AND mají stejný typ - tj. Obě jsou řetězce nebo obojí jsou celá čísla.

109
Jose Vega

Podívejte se na 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.";
    }
?>
59
Haim Evgi

Použití strstr() nebo stristr() pokud by vaše vyhledávání nemělo být citlivé na případy, bylo by to další řešení.

58
glutorange

Peer to SamGoody a Lego Stormtroopr komentuje.

Pokud hledáte algoritmus PHP pro výsledky vyhledávání na základě blízkosti/relevance z více slov zde přichází rychlý a snadný způsob generování výsledků vyhledávání pomocí PHP pouze:

Problémy s jinými metodami boolean vyhledávání, jako jsou strpos(), preg_match(), strstr() nebo stristr()

  1. nelze vyhledat více slov
  2. výsledky jsou nevyužity

PHP metoda založená na Model vektorového prostoru a tf-idf (termín frekvence - inverzní frekvence dokumentu):

Zní to obtížně, ale je to překvapivě snadné.

Chceme-li hledat více slov v řetězci, hlavní problém je, jak každému z nich přiřazujeme váhu?

Pokud bychom mohli vážit termíny v řetězci na základě toho, jak reprezentují řetězec jako celek, mohli bychom naše výsledky objednat podle výsledků, které nejlépe odpovídají dotazu.

Toto je myšlenka modelu vektorového prostoru, daleko od toho, jak SQL fulltextové vyhledávání funguje:

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

PŘÍPAD 1

$query = 'are';

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

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

V&YACUTE;SLEDEK

Array
(
    [1] => 0.52832083357372
)

PŘÍPAD 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>';

V&YACUTE;SLEDKY

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

PŘÍPAD 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>';

V&YACUTE;SLEDKY

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

Existuje spousta vylepšení, která je třeba udělat, ale model poskytuje způsob, jak získat dobré výsledky z přirozených dotazů, které nemají logické operátory, jako jsou strpos(), preg_match(), strstr() nebo stristr().

NOTA BENE

Volitelně odstranění redundance před vyhledáním slov

  • čímž se sníží velikost indexu a výsledkem je menší požadavek na skladování

  • méně diskových I/O

  • rychlejší indexování a následně rychlejší vyhledávání.

1. Normalizace

  • Převést celý text na malá písmena

2. Vyloučení stopword

  • Odstraňte slova z textu, který nemá žádný skutečný význam (jako „a“, „nebo“, „the“, „pro“ atd.)

3. Nahrazení slovníku

  • Nahraďte slova jinými, které mají stejný nebo podobný význam. (např. nahrazení instancí „hladovějících“ a „hladových“ hladem)

  • Další algoritmická opatření (Snowball) mohou být prováděna za účelem dalšího snížení slov na jejich základní význam.

  • Nahrazení názvů barev jejich hexadecimálními ekvivalenty

  • Snížení číselných hodnot snížením přesnosti jsou další způsoby normalizace textu.

ZDROJE

43
RafaSashi

Pokud se chcete vyhnout problému "falsey" a "truthy", můžete použít substr_count:

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

Je to trochu pomalejší než strpos, ale vyhýbá se problémům s porovnáváním.

40
Alan Piralla

Další možností je použít strstr () function. Něco jako:

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

Poznámka: Funkce strstr () rozlišuje velká a malá písmena. Pro vyhledávání nerozlišující velká a malá písmena použijte funkci stristr () .

31
YashG99

Jsem trochu ohromen tím, že žádná z odpovědí zde použitých strpos, strstr a podobných funkcí neuvedla Multibyte String Functions (2015-05-08).

V zásadě, pokud máte máte potíže s hledáním slov se znaky specifickými pro některé jazyky , jako je němčina, francouzština, portugalština, španělština atd. (Např .: ä, é, ô, ç, º, ñ), můžete předcházet funkci s mb_. Přijatá odpověď by proto použila mb_strpos nebo mb_stripos (pro shodu nerozlišující velká a malá písmena):

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

Pokud nemůžete zaručit, že všechna vaše data jsou 100% v UTF-8 , můžete použít funkce mb_.

Dobrý článek pochopit, proč je Absolutní minimum každý vývojář softwaru Absolutně, pozitivně musí vědět o Unicode a znakové sady (bez výmluv!) by Joel Spolsky.

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

Funkce níže také funguje a nezávisí na žádné jiné funkci; používá pouze nativní PHP manipulaci s řetězci. Osobně to nedoporučuji, ale můžete vidět, jak to funguje:

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

Test:

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 
23
Jason OOO

V PHP je nejlepším způsobem, jak ověřit, zda řetězec obsahuje určitý dílčí řetězec, použít jednoduchou pomocnou funkci:

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

Vysvětlení:

  • strpos nalezne pozici prvního výskytu podřetězce rozlišujícího velká a malá písmena v řetězci.
  • stripos nalezne pozici prvního výskytu v řetězci nerozlišujícího malá a velká písmena.
  • myFunction($haystack, $needle) === FALSE ? FALSE : TRUE zajišťuje, že myFunction vždy vrátí boolean a opraví neočekávané chování, když index podřetězce je 0.
  • $caseSensitive ? A : B vybere buď strpos nebo stripos pro provedení práce v závislosti na hodnotě $caseSensitive.

Výstup:

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)
22
John Slegers

Můžete použít funkci strstr:

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

if ($flag){

    echo "true";
}

Bez použití vestavěné funkce:

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

Měl jsem s tím nějaké potíže a nakonec jsem se rozhodl vytvořit vlastní řešení. Bez použití regulárního výrazu engine:

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

Můžete si všimnout, že předchozí řešení nejsou odpovědí pro slovo, které se používá jako předpona pro jiné. Chcete-li použít příklad:

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

S výše uvedenými ukázkami obsahuje $a a $b$c, ale můžete chtít, aby vaše funkce řekla, že $a obsahuje $c.

21
Decebal

Další možností, jak zjistit výskyt slova z řetězce pomocí strstr () a stristr () , je následující:

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

Aby bylo možné najít 'slovo', spíše než výskyt řady dopisů, které by mohly být součástí jiného Wordu, bylo by to dobré řešení.

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

if (in_array('are', $array) ) {
    echo 'Found the Word';
}
14
DJC

Lze to provést třemi různými způsoby:

 $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
 }
14
Shashank Singh

Krátká verze

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

Měli byste použít formát Insensitive case, takže pokud je zadaná hodnota v small nebo caps, nezáleží na tom.

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

Zde stripos najde jehlu v heystacku bez uvažování případu (malé/čepice).

Ukázka PHPCode s výstupem

13
Pratik C Joshi

Mnoho odpovědí, které používají substr_count kontroluje, zda je výsledkem >0. Protože ale příkaz if považuje nulový stejný jako false , můžete se vyhnout tomu, abyste zkontrolovali a zapisovali přímo:

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

Chcete-li zkontrolovat, zda not present, přidejte operátora !:

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

Možná byste mohli něco takového použít:

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

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

Nepoužívejte preg_match() pokud chcete zkontrolovat, zda je jeden řetězec obsažen v jiném řetězci. Místo toho použijte strpos() nebo strstr(), protože budou rychlejší. ( http://in2.php.net/preg_match )

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

Chcete-li zkontrolovat, zda řetězec obsahuje několik specifických slov, můžete provést:

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

To je užitečné například při vyhýbání se spamu při odesílání e-mailů.

10
Julien

Musíte použít identické/ne identické operátory, protože strpos může vrátit hodnotu 0 jako hodnotu indexu. Pokud se vám líbí ternární operátoři, zvažte použití následujícího postupu (zdá se, že připouštím trochu dozadu):

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

Funkce strpos funguje dobře, ale pokud chcete udělat case-insensitive kontrolu Wordu v odstavci, pak můžete použít stripos funkci PHP.

Například,

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

Najděte pozici prvního výskytu podřetězce nerozlišujícího velká a malá písmena v řetězci.

Pokud slovo neexistuje v řetězci, pak se vrátí falešné, jinak vrátí pozici Wordu.

9
Akshay Khale

Zkontrolujte, zda řetězec obsahuje konkrétní slova?

To znamená, že řetězec musí být vyřešen slovy (viz poznámka níže).

Jedním ze způsobů, jak to provést a určit separátory, je použití 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');

?>

Běh dává

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

Poznámka: Zde neznamená slovo pro každou posloupnost symbolů.

Praktická definice Wordu je ve smyslu regulárního výrazu PCRE, kde slova jsou podřetězce tvořené pouze znaky Wordu, které jsou odděleny znaky, které nejsou v aplikaci Word.

Znak "Word" je libovolné písmeno nebo číslice nebo znak podtržítka, to znamená jakýkoli znak, který může být součástí "Wordu" Perlu. Definice písmen a číslic je řízena tabulkami znaků programu PCRE a může se lišit v případě, že dochází k přizpůsobení specifickým pro národní prostředí (..)

8
mvw

Řetězec lze zkontrolovat pomocí níže uvedené funkce:

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

Další řešení pro konkrétní řetězec:

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

Můžete také použít funkci strpos().

6
devpro

Použití:

$text = 'This is a test';
echo substr_count($text, 'is'); // 2

// So if you want to check if is exists in the text just put
// in a condition like this:
if (substr_count($text, 'is') > 0) {
    echo "is exists";
}
5
Kamaro Lambert

Jednodušší možnost:

return ( ! empty($a) && strpos($a, 'are'))? true : false;
4
ShirleyCC

Myslím, že dobrý nápad je použít mb_stpos:

$haystack = 'How are you?';
$needle = 'are';

if (mb_strpos($haystack, $needle) !== false) {

    echo 'true';
}

Protože toto řešení je rozlišuje velká a malá písmenaa bezpečné pro všechny znaky Unicode.


Můžete to ale také udělat takto ( odpověď seuch ještě nebyla ):

if (count(explode($needle, $haystack)) > 1) {

    echo 'true';
}

Toto řešení je také rozlišuje velká a malá písmenaa bezpečné pro znaky Unicode.

Kromě toho nepoužívejte negaci ve výrazu, což zvyšuje čitelnost kódu.


Zde je další řešení pomocí funkce:

function isContainsStr($haystack, $needle) {

    return count(explode($needle, $haystack)) > 1;
}

if (isContainsStr($haystack, $needle)) {

    echo 'true';
}
4
simhumileco

Použití:

$a = 'How are you?';
if (mb_strpos($a, 'are')) {
    echo 'true';
}

Provádí vícebajtovou bezpečnou strpos () operaci.

3
Mindexperiment

Můžete také použít vestavěné funkce strchr() a strrchr() a rozšíření pro vícebajtové řetězce mb_strchr() a mb_strrchr() . Tyto funkce vracejí části řetězců a FALSE, pokud není nalezeno nic.

  • strchr() - Najít první výskyt řetězce (je alias strstr() ).
  • strrchr() - Najít poslední výskyt znaku v řetězci.
3
Aleksey Bykov