tem - verificar se uma string está contida em outra php




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

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 ):

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

Uma corrida dá

<?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');

?>

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

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

Um caractere de "palavra" é qualquer letra ou dígito ou o caractere de sublinhado, ou seja, 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 (..)

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


A função abaixo também funciona e não depende de nenhuma outra função; Ele usa apenas manipulação de strings nativas do 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 

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

Embora a maioria dessas respostas mostre se uma substring aparece na sua string, geralmente não é isso que você deseja se estiver procurando por uma determinada palavra , e não uma substring .

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

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

Uma maneira de atenuar isso seria usar uma expressão regular associada a 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 mencionados acima, mas possui alguns casos de borda próprios. Os limites de palavra correspondem a caracteres não word ( \W ), que serão qualquer coisa que não seja az , AZ , 0-9 ou _ . Isso significa que dígitos e sublinhados serão contados como caracteres de palavras e cenários como esse falharão:

  • O "está" em "O que você está pensando?"
  • Os "estã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 da língua inglesa, e isso é uma grande lata de worms (e pressupõe o uso adequado da sintaxe, de qualquer forma, o que nem sempre é um dado).


Eu tive alguns problemas com isso e, finalmente, optei por criar minha própria solução. Sem usar o mecanismo de expressão regular :

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 a palavra que está sendo usada como um prefixo para outra. Para usar seu exemplo:

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

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


Faça uso da correspondência entre maiúsculas e minúsculas usando stripos() :

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

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

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

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

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

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

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


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 stristr() entre maiúsculas e minúsculas, use a função stristr() .


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

?>

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 ​​/ expresões / constantes são iguais AND têm o mesmo tipo - isto é, ambas são cadeias de caracteres ou ambos são números inteiros.


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

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

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

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

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

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


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

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

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


Você deve usar maiúsculas e minúsculas no formato Insensitive, portanto, se o valor inserido for em small ou em caps , 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 os stripos encontram a agulha no heystack sem considerar o caso (small / caps).

Amostra PHPCode com saída


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

Note 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') .


Você poderia usar expressões regulares, é melhor para correspondência de palavras comparado a strpos como mencionado por outros usuários, ele também retornará true para strings como tarifa, cuidado, stare etc. Isso pode simplesmente ser evitado na expressão regular usando limites de palavra.

Uma correspondência simples para é algo parecido com 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, levou uma partida preg 1.5 segundos para terminar e por 0.5 segundos demorou.


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):

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

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

A função strpos funciona bem, mas se você quiser fazer a case-insensitiveverificação de uma palavra em um parágrafo, então você pode fazer uso da striposfunção de PHP.

Por exemplo,

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

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 a palavra não existir na string, ela retornará false ou retornará a posição da palavra.





string-matching