ti-enxame.com

Como faço para verificar se uma string contém uma palavra específica?

Considerar:

$a = 'How are you?';

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

Suponha que eu tenha o código acima, qual é a maneira correta de escrever a declaração if ($a contains 'are')?

2666
Charles Yeung

Você pode usar a função strpos() que é usada para encontrar a ocorrência de uma string dentro de outra:

$a = 'How are you?';

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

Observe que o uso de !== false é deliberado; strpos() retorna o offset no qual a string de agulha começa na string do haystack, ou o booleano false se a agulha não for encontrada. Como 0 é um offset válido e 0 é "falsey", não podemos usar construções mais simples como !strpos($a, 'are').

6129
codaddict

Você poderia usar expressões regulares, é melhor para a correspondência do Word em comparação com strpos como mencionado por outros usuários que também retornará true para strings como tarifa, cuidado, stare, etc. Isso pode ser simplesmente evitado na expressão regular usando limites do Word.

Uma simples correspondência para pode ser algo como isto:

$a = 'How are you?';

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

No lado do desempenho, strpos é cerca de três vezes mais rápido e tenho em mente, quando eu fiz um milhão de comparações de uma só vez, demorou preg_match 1,5 segundos para terminar e para strpos levou 0,5 segundos.

Edit: Para pesquisar qualquer parte da string, não apenas o Word by Word, eu recomendaria usar uma expressão regular como

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

O i no final da expressão regular muda a expressão regular para não diferenciar maiúsculas de minúsculas, se você não quiser isso, você pode deixar de fora.

Agora, isso pode ser bastante problemático em alguns casos, pois a string $ search não é higienizada de qualquer forma, quer dizer, pode não passar a verificação em alguns casos, como se $search fosse uma entrada do usuário, eles poderiam adicionar algumas strings que poderiam se comportar como uma expressão regular diferente ...

Além disso, aqui está uma ótima ferramenta para testar e ver explicações de várias expressões regulares Regex101

Para combinar os dois conjuntos de funcionalidades em uma única função multifuncional (inclusive com sensibilidade a maiúsculas e minúsculas selecionável), você poderia usar algo assim:

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

Aqui está uma pequena função de utilidade que é útil em situações como esta

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

Enquanto a maioria destas respostas lhe dirá se uma substring aparece na sua string, geralmente não é o que você quer se você está procurando por um Word , e não um substring .

Qual é a diferença? Substrings podem aparecer em outras palavras:

  • O "são" no começo da "área"
  • O "são" no final da "lebre"
  • Os "estão" no meio de "tarifas"

Uma maneira de atenuar isso seria usar uma expressão regular junto com limites de palavra (\b):

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

Esse método não possui os mesmos falsos positivos observados acima, mas ele possui alguns casos Edge próprios. Os limites de palavras correspondem a caracteres que não sejam do Word (\W), que serão qualquer coisa que não seja a-z, A-Z, 0-9 ou _. Isso significa que dígitos e sublinhados serão contados como caracteres do Word e cenários como esse falharão:

  • O "está" em "O que você está pensando?"
  • O "são" em "lol u dunno wut esses are4?"

Se você quiser algo mais preciso do que isso, você terá que começar a fazer a sintaxe do idioma inglês, e isso é uma grande quantidade de worms (e pressupõe o uso adequado da sintaxe, de qualquer forma, o que nem sempre é dado).

128
FtDRbwLXw6

Para determinar se uma string contém outra string, você pode usar o PHP function 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";
}

?>

CUIDADO:

Se a agulha que você está procurando estiver no início do palheiro, ela retornará a posição 0, se você fizer uma comparação == que não funcionará, você precisará fazer um ===

Um sinal == é uma comparação e testa se a variável/expressão/constante à esquerda tem o mesmo valor que a variável/expressão/constante à direita.

Um sinal === é uma comparação para ver se duas variáveis ​​/ expresions/constantes são iguais AND possuem o mesmo tipo - ou seja, ambas são strings ou ambos são inteiros.

109
Jose Vega

Olhe para 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

Usar strstr() ou stristr() se a sua pesquisa não for diferencia maiúsculas de minúsculas, seria outra opção.

58
glutorange

Peer to SamGoody e Lego Stormtroopr comenta.

Se você está procurando um algoritmo PHP para classificar os resultados da pesquisa com base na proximidade/relevância de várias palavras, vem uma maneira rápida e fácil de gerar resultados de pesquisa somente com PHP:

Problemas com outros métodos de pesquisa booleana, como strpos(), preg_match(), strstr() ou stristr()

  1. não é possível procurar por várias palavras
  2. resultados não são classificados

PHP método baseado em Modelo de espaço vetorial e tf-idf (frequência de termo - frequência de documento inverso):

Parece difícil, mas é surpreendentemente fácil.

Se quisermos pesquisar várias palavras em uma string, o problema central é como atribuímos um peso a cada uma delas?

Se pudéssemos ponderar os termos em uma string com base em como eles são representativos da string como um todo, poderíamos solicitar nossos resultados pelos que melhor correspondessem à consulta.

Esta é a idéia do modelo de espaço vetorial, não muito longe de como funciona a pesquisa de texto completo do 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;
}

CASO 1

$query = 'are';

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

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

RESULTADO

Array
(
    [1] => 0.52832083357372
)

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

RESULTADOS

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

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

RESULTADOS

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

Há muitas melhorias a serem feitas, mas o modelo fornece uma maneira de obter bons resultados de consultas naturais, que não têm operadores booleanos, como strpos(), preg_match(), strstr() ou stristr().

NOTE BENE

Eliminando a redundância antes de pesquisar as palavras

  • reduzindo assim o tamanho do índice e resultando em menor necessidade de armazenamento

  • menos disco I/O

  • indexação mais rápida e uma busca consequentemente mais rápida.

1. Normalização

  • Converter todo o texto para minúsculas

2. Eliminação de stopword

  • Eliminar palavras do texto que não têm significado real (como 'e', ​​'ou', 'the', 'for' etc.)

3. Substituição de dicionário

  • Substitua palavras por outras que tenham um significado idêntico ou semelhante. (ex: substituir instâncias de 'fome' e 'fome' por 'fome')

  • Outras medidas algorítmicas (bola de neve) podem ser realizadas para reduzir ainda mais as palavras ao seu significado essencial.

  • A substituição de nomes de cores por seus equivalentes hexadecimais

  • A redução de valores numéricos reduzindo a precisão são outras formas de normalizar o texto.

RESOURCES

43
RafaSashi

Faça uso de correspondência insensível a maiúsculas usando stripos() :

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

Se você quiser evitar o problema "falsey" e "truthy", você pode usar o substr_count:

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

É um pouco mais lento que strpes, mas evita os problemas de comparação.

40
Alan Piralla

Outra opção é usar a função strstr () . Algo como:

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

Aponte para observar: A função strstr () faz distinção entre maiúsculas e minúsculas. Para uma pesquisa sem distinção entre maiúsculas e minúsculas, use a função stristr () .

31
YashG99

Estou um pouco impressionado que nenhuma das respostas aqui que usei strpos, strstr e funções semelhantes mencionadas Funções de String Multibyte yet (2015-05-08).

Basicamente, se você está tendo problemas para encontrar palavras com caracteres específicos para alguns idiomas , como alemão, francês, português, espanhol, etc. (por exemplo: ä, é, ô, ç, º, ñ), você pode querer preceder as funções com mb_. Portanto, a resposta aceita usaria mb_strpos ou mb_stripos (para correspondência sem distinção entre maiúsculas e minúsculas):

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

Se você não pode garantir que todos os seus dados são 100% em UTF-8 , você pode querer usar as funções mb_.

Um bom artigo para entender por que é O Mínimo Absoluto Todo Desenvolvedor de Software Absolutamente, Positivamente Deve Saber Sobre Unicode e Conjuntos de Caracteres (Sem desculpas!)por Joel Spolsky.

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

A função abaixo também funciona e não depende de nenhuma outra função; ele usa apenas manipulação de strings nativas PHP. Pessoalmente, eu não recomendo isso, mas você pode ver como funciona:

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

Teste:

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

No PHP, a melhor maneira de verificar se uma string contém uma certa substring, é usar uma função auxiliar simples como esta:

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

Explicação:

  • strpos localiza a posição da primeira ocorrência de uma subseqüência de diferenciação de maiúsculas e minúsculas em uma seqüência de caracteres.
  • stripos localiza a posição da primeira ocorrência de uma subseqüência insensível a maiúsculas e minúscula em uma seqüência de caracteres.
  • myFunction($haystack, $needle) === FALSE ? FALSE : TRUE garante que myFunction sempre retorne um booleano e corrija comportamento inesperado quando o índice da substring for 0.
  • $caseSensitive ? A : B seleciona strpos ou stripos para fazer o trabalho, dependendo do valor de $caseSensitive.

Saída:

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

Você pode usar a função strstr:

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

if ($flag){

    echo "true";
}

Sem usar uma função inbuilt:

$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

Eu tive alguns problemas com isso e, finalmente, optei por criar minha própria solução. Sem usar expressão regular 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;
 }

Você pode notar que as soluções anteriores não são uma resposta para o Word sendo usado como um prefixo para outro. Para usar seu exemplo:

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

Com as amostras acima, $a e $b contém $c, mas você pode querer que sua função lhe diga que apenas $a contém $c.

21
Decebal

Outra opção para encontrar a ocorrência de um Word a partir de uma string usando strstr () e stristr () é como o seguinte:

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

Para encontrar uma 'Palavra', em vez da ocorrência de uma série de letras que poderiam de fato fazer parte de outra Palavra, a seguinte seria uma boa solução.

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

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

Isso pode ser feito de três maneiras diferentes:

 $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

A versão de mão curta

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

Você deve usar o formato Insensitive case, portanto, se o valor inserido estiver em small ou caps, isso não importará.

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

Aqui stripos encontra a agulha no heystack sem considerando o caso (small/caps).

Amostra PHPCode com saída

13
Pratik C Joshi

Muitas respostas que usam substr_count verificam se o resultado é >0. Mas como a instrução if considera zero o o mesmo que false , você pode evitar essa verificação e escrever diretamente:

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

Para verificar se não presente, adicione o operador !:

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

Talvez você possa usar algo assim:

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

Não use preg_match() se você quiser apenas verificar se uma string está contida em outra string. Use strpos() ou strstr(), pois eles serão mais rápidos. ( http://in2.php.net/preg_match )

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

Se você quiser verificar se a string contém várias palavras específicas, você pode fazer:

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

Isso é útil para evitar spam ao enviar e-mails, por exemplo.

10
Julien

Você precisa usar operadores idênticos/não idênticos, porque strpos podem retornar 0 como seu valor de índice. Se você gosta de operadores ternários, considere usar o seguinte (parece um pouco para trás, eu admito):

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

A função strpos funciona bem, mas se você quiser fazer case-insensitive verificação de um Word em um parágrafo, então você pode fazer uso da função stripos de PHP.

Por exemplo,

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

Encontre a posição da primeira ocorrência de uma subseqüência insensível a maiúsculas e minúscula em uma seqüência de caracteres.

Se o Word não existir na string, ele retornará false, caso contrário, retornará a posição da Palavra.

9
Akshay Khale

Verificar se a string contém palavras específicas?

Isso significa que a string deve ser resolvida em palavras (veja a nota abaixo).

Uma maneira de fazer isso e especificar os separadores é usando 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');

?>

Uma corrida dá

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

Nota: Aqui não queremos dizer Word para cada sequência de símbolos.

Uma definição prática do Word é no sentido do mecanismo de expressão regular PCRE, em que palavras são substrings constituídas apenas por caracteres do Word, sendo separadas por caracteres não Word.

Um caractere "Palavra" é qualquer letra ou dígito ou o caractere de sublinhado, isto é, qualquer caractere que possa fazer parte de uma "Palavra" Perl. A definição de letras e dígitos é controlada pelas tabelas de caracteres do PCRE e pode variar se a correspondência específica do local estiver ocorrendo (..)

8
mvw

Uma string pode ser verificada com a função abaixo:

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

Outra solução para uma string específica:

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

Você também pode usar a função strpos().

6
devpro

Usar:

$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

Uma opção mais simples:

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

Eu acho que uma boa idéia é usar mb_stpos:

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

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

    echo 'true';
}

Porque esta solução é case sensitive e safe para todos os caracteres Unicode .


Mas você também pode fazer assim ( essa resposta ainda não foi ):

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

    echo 'true';
}

Essa solução também é diferencia maiúsculas de minúsculas e safe para caracteres Unicode .

Além disso, você não usa a negação na expressão , que aumenta a legibilidade do código .


Aqui está outra solução usando a função :

function isContainsStr($haystack, $needle) {

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

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

    echo 'true';
}
4
simhumileco

Usar:

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

Ele executa uma operação strakes () segura de múltiplos bytes.

3
Mindexperiment

Você também pode usar funções internas strchr() e strrchr() e extensões para strings multibyte mb_strchr() e mb_strrchr() . Essas funções retornam partes de strings e FALSE se nada for encontrado.

  • strchr() - Encontre a primeira ocorrência de uma string (é um alias de strstr() ).
  • strrchr() - Encontre a última ocorrência de um caractere em uma string.
3
Aleksey Bykov