¿Cómo verifico si una cadena contiene una palabra específica?

Considerar:

$a = 'How are you?';

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

Supongamos que tengo el código anterior, ¿cuál es la forma correcta de escribir la declaración? if ($a contains 'are')?

preguntado el 06 de diciembre de 10 a las 10:12

30 Respuestas

Puede utilizar el strpos() función que se usa para encontrar la ocurrencia de una cadena dentro de otra:

$a = 'How are you?';

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

Tenga en cuenta que el uso de !== false es deliberado (ni != false ni === true devolverá el resultado deseado); strpos() devuelve el desplazamiento en el que comienza la cadena de agujas en la cadena del pajar, o el booleano false si no se encuentra la aguja. Dado que 0 es un desplazamiento válido y 0 es "falso", no podemos usar construcciones más simples como !strpos($a, 'are').

Ahora con PHP 8 puedes hacer esto usando str_contiene:

if (str_contains('How are you', 'are')) { 
    echo 'true';
}

RFC

respondido 18 mar '21, 16:03

@DTest - bueno, sí, por supuesto, devolverá verdadero porque la cadena contiene 'are'. Si está buscando específicamente la palabra ARE, entonces necesitaría hacer más verificaciones como, por ejemplo, verificar si hay un carácter o un espacio antes de la A y después de la E. - jsherk

Muy buenos comentarios arriba! Nunca uso! = O ==, después de todo! == y === es la mejor opción (en mi opinión) considerando todos los aspectos (velocidad, precisión, etc.). - Melsi

@jsherk ¿Por qué no expresiones regulares, entonces? Algo como "son". - Julio Muscarello

En cuanto a no detectar 'cuidado' y esas cosas, es mejor verificar (strpos (''. Strtolower ($ a). '', 'Are')! == false) - Wouter

Tiendo a evitar este problema usando siempre strpos($a, 'are') > -1 para probar la verdad. Desde una perspectiva de depuración, encuentro que mi cerebro desperdicia menos ciclos de reloj determinando si la línea está escrita correctamente cuando no tengo que contar signos iguales contiguos. - ecuación

Puede utilizar expresiones regulares, ya que es mejor para la concordancia de palabras en comparación con strpos, como lo mencionan otros usuarios. A strpos comprobar are también devolverá verdadero para cadenas como: tarifa, cuidado, mirada, etc. Estas coincidencias no deseadas pueden simplemente evitarse en expresiones regulares mediante el uso de límites de palabras.

Un simple partido para are podría verse algo como esto:

$a = 'How are you?';

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

Por el lado del rendimiento, strpos es aproximadamente tres veces más rápido. Cuando hice un millón de comparaciones a la vez, tomó preg_match 1.5 segundos para terminar y por strpos tomó 0.5 segundos.

Editar: para buscar en cualquier parte de la cadena, no solo palabra por palabra, recomendaría usar una expresión regular como

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

El sistema i al final de la expresión regular cambia la expresión regular para que no distinga entre mayúsculas y minúsculas; si no lo desea, puede omitirla.

Ahora, esto puede ser bastante problemático en algunos casos, ya que la cadena $ search no está desinfectada de ninguna manera, quiero decir, es posible que no pase la verificación en algunos casos como si $search es una entrada del usuario, pueden agregar alguna cadena que podría comportarse como una expresión regular diferente ...

Además, aquí hay una gran herramienta para probar y ver explicaciones de varias expresiones regulares. Regex101

Para combinar ambos conjuntos de funciones en una única función multipropósito (incluso con distinción entre mayúsculas y minúsculas seleccionable), puede usar algo como esto:

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

Una cosa más a tener en cuenta es que \b no funcionará en otros idiomas además del inglés.

La explicación de esto y la solución se toman de aquí.:

\b representa el principio o el final de una palabra (límite de palabra). Esta expresión regular coincidiría con la manzana en un pastel de manzana, pero no coincidiría con la manzana en la piña, los carritos de manzana o las manzanas para hornear.

¿Qué tal "café"? ¿Cómo podemos extraer la palabra "café" en expresiones regulares? En realidad, \ bcafé \ b no funcionaría. ¿Por qué? Porque "café" contiene caracteres no ASCII: é. \ b no se puede usar simplemente con Unicode como समुद्र, 감사, месяц y 😉.

Cuando desee extraer caracteres Unicode, debe definir directamente los caracteres que representan los límites de las palabras.

La respuesta: (?<=[\s,.:;"']|^)UNICODE_WORD(?=[\s,.:;"']|$)

Entonces, para usar la respuesta en PHP, puede usar esta función:

function contains($str, array $arr) {
    // Works in Hebrew and any other unicode characters
    // Thanks https://medium.com/@shiba1014/regex-word-boundaries-with-unicode-207794f6e7ed
    // Thanks https://www.phpliveregex.com/
    if (preg_match('/(?<=[\s,.:;"\']|^)' . $word . '(?=[\s,.:;"\']|$)/', $str)) return true;
}

Y si desea buscar una variedad de palabras, puede usar esto:

function arrayContainsWord($str, array $arr)
{
    foreach ($arr as $word) {
        // Works in Hebrew and any other unicode characters
        // Thanks https://medium.com/@shiba1014/regex-word-boundaries-with-unicode-207794f6e7ed
        // Thanks https://www.phpliveregex.com/
        if (preg_match('/(?<=[\s,.:;"\']|^)' . $word . '(?=[\s,.:;"\']|$)/', $str)) return true;
    }
    return false;
}

A partir de PHP 8.0.0 ahora puede usar str_contiene

<?php
    if (str_contains('abc', '')) {
        echo "Checking the existence of the empty string will always 
        return true";
    }

Respondido 19 Feb 21, 11:02

@ Alexander.Plutov, en segundo lugar, ¿me estás dando un -1 y no la pregunta? Vamos, se necesitan 2 segundos para buscar en Google la respuesta. google.com/… - Breezer

+1 Es una forma horrible de buscar una cadena simple, pero muchos visitantes de SO están buscando cualquier forma de buscar cualquiera de sus propias subcadenas, y es útil que la sugerencia haya surgido. Incluso el OP podría haber simplificado demasiado: hágale saber sus alternativas. - SamGoody

Técnicamente, la pregunta es cómo encontrar palabras no una subcadena. Esto realmente me ayudó, ya que puedo usar esto con límites de palabras regex. Las alternativas siempre son útiles. - usuario764357

+1 para la respuesta y -1 al comentario de @ plutov.by porque, strpos es solo una verificación única, mientras que regexp puede verificar muchas palabras al mismo tiempo, por ejemplo: preg_match (/ are | you | not /) - Albanx

Las expresiones regulares deben ser el método de último recurso. Debe desalentarse su uso en tareas triviales. Insisto en esto desde el apogeo de muchos años de excavar códigos incorrectos. - yentsun

Aquí hay una pequeña función de utilidad que es útil en situaciones como esta

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

Respondido 18 ago 11, 19:08

@RobinvanBaalen En realidad, puede mejorar la legibilidad del código. Además, se supone que los votos negativos son para respuestas (muy) malas, no para respuestas "neutrales". - Xaqq

Las funciones de @RobinvanBaalen son casi por definición de legibilidad (para comunicar la idea de lo que estás haciendo). Compare cuál es más legible: if ($email->contains("@") && $email->endsWith(".com)) { ... or if (strpos($email, "@") !== false && substr($email, -strlen(".com")) == ".com") { ... - Brandin

@RobinvanBaalen al final, las reglas están destinadas a romperse. De lo contrario, a la gente no se le ocurrirían nuevas formas inventivas de hacer las cosas :). Además, tengo que admitir que tengo problemas para pensar en cosas como martinfowler.com. Supongo que lo correcto es probar las cosas usted mismo y averiguar qué enfoques son los más convenientes. - James P.

Otra opinión: tener una función de utilidad que pueda ajustar fácilmente puede ayudar a depurar. También grita por buenos optimizadores que eliminen tales gastos generales en los servicios de producción. Entonces todas las opiniones tienen puntos válidos. ;) - Tino

Por supuesto que esto es útil. Deberías alentar esto. ¿Qué sucede si en PHP 100 hay una forma nueva y más rápida de encontrar ubicaciones de cadenas? ¿Quieres cambiar todos tus lugares donde llamas strpos? ¿O desea cambiar solo el contenido dentro de la función? - Cosmin

Si bien la mayoría de estas respuestas le dirán si aparece una subcadena en su cadena, generalmente eso no es lo que desea si está buscando una subcadena en particular. por el temor y no un subcadena.

¿Cual es la diferencia? Las subcadenas pueden aparecer dentro de otras palabras:

  • El "son" al principio de "área"
  • El "son" al final de "liebre"
  • Los "están" en medio de "tarifas"

Una forma de mitigar esto sería usar una expresión regular junto con límites de palabras (\b):

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

Este método no tiene los mismos falsos positivos señalados anteriormente, pero tiene algunos casos extremos propios. Los límites de las palabras coinciden con los caracteres que no son palabras (\W), que será cualquier cosa que no sea a-z, A-Z, 0-9 o el _. Eso significa que los dígitos y los guiones bajos se contarán como caracteres de palabra y los escenarios como este fallarán:

  • Los "están" en "¿Qué _estás_ pensando?"
  • Los "están" en "lol u no sé, ¿esos son 4?"

Si desea algo más preciso que esto, tendrá que comenzar a analizar la sintaxis en inglés, y esa es una gran cantidad de gusanos (y asume el uso adecuado de la sintaxis, de todos modos, lo que no siempre es un hecho).

Respondido el 22 de enero de 17 a las 14:01

esta debería ser la respuesta canónica. Porque estamos buscando palabras y no subcadenas, la expresión regular es apropiada. También agregaré eso \b coincide con dos cosas que \W no lo hace, lo que lo hace ideal para encontrar palabras en una cadena: coincide con el comienzo de la cadena (^) y final de cadena ($) - código_monk

esta debería ser la respuesta correcta .. el resto de las respuestas encontrarán "son" en una cadena como "te importa" .. Como lo menciona @Dtest - Robert Sinclair

@RobertSinclair ¿Eso es tan malo? Si me preguntaras si la cadena "te importa" contiene la palabra "son", diría "sí". La palabra "son" es claramente una subcadena de esa cadena. Esa es una pregunta separada de "" "Es" son "una de las palabras en la cadena" te importa "" "". - Paul

@Paulpro A pesar de que OP no especificó que $ a es una frase, estoy bastante seguro de que estaba implícito. Entonces su pregunta era cómo detectar la Palabra dentro de la Frase. No si una palabra contiene una palabra dentro de ella, lo que supongo que sería irrelevante la mayoría de las veces. - Robert Sinclair

@Jimbo funciona, solo te falta el `\` 3v4l.org/ZRpYi - metalraro

Para determinar si una cadena contiene otra cadena, puede usar la función 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";
}

?>

AVISO:

Si la aguja que está buscando está al principio del pajar, volverá a la posición 0, si hace una == comparar que no funcionará, tendrá que hacer un ===

A == El signo es una comparación y prueba si la variable / expresión / constante de la izquierda tiene el mismo valor que la variable / expresión / constante de la derecha.

A === el signo es una comparación para ver si dos variables / expresiones / constantes son iguales AND tienen el mismo tipo, es decir, ambos son cadenas o ambos son números enteros.

Respondido 09 Abr '21, 08:04

Si uso "cuidado", su retorno también es verdadero :( - Jahirul Islam Mamun

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

Respondido el 24 de Septiembre de 13 a las 19:09

Usar strstr() or stristr() si su búsqueda no distingue entre mayúsculas y minúsculas sería otra opción.

Respondido el 24 de Septiembre de 13 a las 19:09

Una nota sobre el php.net/manual/en/function.strstr.php página: Nota: Si solo desea determinar si una aguja en particular ocurre dentro del pajar, use la función strpos (), más rápida y con menos memoria. - jo smo

@tastro ¿Hay puntos de referencia de buena reputación sobre esto? - Wayne Whitty

Esto podría ser más lento, pero en mi humilde opinión strstr($a, 'are') es mucho más elegante que lo feo strpos($a, 'are') !== false. PHP realmente necesita un str_contains() función. - Pablo Spiegel

Me sorprende que esta no sea la respuesta aceptada: kurdtpage

Mira los comentarios de SamGoody y Lego Stormtroopr.

Si está buscando un algoritmo PHP para clasificar los resultados de búsqueda según la proximidad / relevancia de varias palabras aquí viene una forma rápida y fácil de generar resultados de búsqueda solo con PHP:

Problemas con los otros métodos de búsqueda booleanos como strpos(), preg_match(), strstr() or stristr()

  1. no puedo buscar varias palabras
  2. los resultados no están clasificados

Método PHP basado en Modelo de espacio vectorial y tf-idf (término frecuencia – frecuencia inversa del documento):

Suena difícil pero sorprendentemente fácil.

Si queremos buscar varias palabras en una cadena, el problema central es cómo asignamos un peso a cada una de ellas.

Si pudiéramos ponderar los términos de una cadena en función de lo representativos que sean de la cadena en su conjunto, podríamos ordenar nuestros resultados según los que mejor se ajusten a la consulta.

Esta es la idea del modelo de espacio vectorial, no muy lejos de cómo funciona la búsqueda de texto completo de 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
)

Se pueden realizar muchas mejoras, pero el modelo proporciona una forma de obtener buenos resultados a partir de consultas naturales, que no tienen operadores booleanos como strpos(), preg_match(), strstr() or stristr().

NOTA BENE

Opcionalmente eliminando la redundancia antes de buscar las palabras

  • reduciendo así el tamaño del índice y resultando en menos requisitos de almacenamiento

  • menos E / S de disco

  • indexación más rápida y, en consecuencia, una búsqueda más rápida.

1. Normalización

  • Convertir todo el texto a minúsculas

2. Eliminación de palabras clave

  • Elimine las palabras del texto que no tengan un significado real (como 'y', 'o', 'el', 'para', etc.)

3. Sustitución de diccionario

  • Reemplace palabras con otras que tengan un significado idéntico o similar. (por ejemplo: reemplace las instancias de 'hambriento' y 'hambriento' con 'hambre')

  • Se pueden realizar más medidas algorítmicas (bola de nieve) para reducir aún más las palabras a su significado esencial.

  • El reemplazo de nombres de colores con sus equivalentes hexadecimales.

  • La reducción de valores numéricos reduciendo la precisión son otras formas de normalizar el texto.

RECURSOS

Respondido el 24 de diciembre de 17 a las 11:12

Hacer uso de coincidencia que no distingue entre mayúsculas y minúsculas usar stripos():

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

contestado el 25 de mayo de 14 a las 04:05

Si desea evitar el problema de la "falsedad" y la "verdad", puede utilizar substr_count:

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

Es un poco más lento que strpos pero evita los problemas de comparación.

Respondido 09 Jul 13, 09:07

Vuelve false para "¿estás seguro?" desde el puesto para strpos is 0 - Hafenkranich

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

Respondido 14 Oct 18, 21:10

Recibo la siguiente advertencia: WARNING preg_match(): Delimiter must not be alphanumeric or backslash - Patros

Otra opción es usar el strstr () función. Algo como:

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

Nota: la función strstr () distingue entre mayúsculas y minúsculas. Para una búsqueda que no distingue entre mayúsculas y minúsculas, utilice la stristr () función.

Respondido 20 ago 12, 17:08

strstr () devuelve FALSE si no se encontró la aguja. Entonces no es necesario un strlen. - AKS

Estoy un poco impresionado de que ninguna de las respuestas aquí que usaban strpos, strstr y funciones similares mencionadas Funciones para cadenas multibyte todavía (2015/05/08).

Básicamente, si estás tener problemas para encontrar palabras con caracteres específicos de algunos idiomas, como alemán, francés, portugués, español, etc. (por ejemplo: ä, é, ô, ç, º, ñ), es posible que desee anteponer las funciones con mb_. Por lo tanto, la respuesta aceptada usaría mb_strpos or mb_stripos (para coincidencias que no distinguen entre mayúsculas y minúsculas) en su lugar:

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

Si no puede garantizar que todos tus datos están 100% en UTF-8, es posible que desee utilizar el mb_ funciones.

Un buen artículo para entender por qué es El mínimo absoluto que todo desarrollador de software debe saber absolutamente, positivamente sobre los conjuntos de caracteres y Unicode (¡sin excusas!) by joel spolski.

contestado el 23 de mayo de 17 a las 13:05

En PHP, la mejor manera de verificar si una cadena contiene una determinada subcadena es usar una función auxiliar simple como esta:

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

Explicación:

  • strpos encuentra la posición de la primera aparición de una subcadena que distingue entre mayúsculas y minúsculas en una cadena.
  • stripos encuentra la posición de la primera aparición de una subcadena que no distingue entre mayúsculas y minúsculas en una cadena.
  • myFunction($haystack, $needle) === FALSE ? FALSE : TRUE asegura que myFunction siempre devuelve un valor booleano y corrige el comportamiento inesperado cuando el índice de la subcadena es 0.
  • $caseSensitive ? A : B selecciona ya sea strpos or stripos para hacer el trabajo, dependiendo del valor de $caseSensitive.

Salida:

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)

Respondido el 12 de diciembre de 17 a las 16:12

Puede utilizar el strstr función:

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

if ($flag){

    echo "true";
}

Sin usar una función incorporada:

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

contestado el 21 de mayo de 17 a las 12:05

Accidentes si busca la primera palabra. - T30

La función siguiente también funciona y no depende de ninguna otra función; utiliza únicamente la manipulación de cadenas PHP nativas. Personalmente, no recomiendo esto, pero puedes ver cómo 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;
  }
}

Prueba:

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 

contestado el 18 de mayo de 15 a las 11:05

¿Podría decirme por qué en el mundo usaría una función como esta, cuando strpos es una solución perfectamente viable? ... - sg3s

@ sg3s: tienes toda la razón, sin embargo, strpos también se basa en algo así, además, no lo publiqué para representante solo por compartir un poco de conocimiento - jason

el último var_dump es falso - Soleada

@Sunny: fue un error tipográfico: var_dump (is_str_contain ("mystringss", "strings")); //cierto - jason

Tuve algunos problemas con esto y finalmente decidí crear mi propia solución. Sin uso expresión regular motor

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

Puede notar que las soluciones anteriores no son una respuesta para la palabra que se usa como prefijo para otra. Para usar su ejemplo:

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

Con las muestras anteriores, ambos $a y $b contiene $c, pero es posible que desee que su función le diga que solo $a contiene $c.

Respondido el 25 de junio de 16 a las 20:06

probablemente quisiste decir: $found = false al principio - ralentización

es posible que su función no funcione si la palabra está vinculada con una coma, un signo de interrogación o un punto. por ejemplo, "lo que ves es lo que obtienes". y desea determinar si "obtener" está en la oración. Observe el punto al lado de "get". En este caso, su función devuelve falso. se recomienda usar expresión regular o substr (creo que usa expresión regular de todos modos) para buscar / reemplazar cadenas. - portador de la luz

@lightbringer no podrías estar más equivocado con tu recomendación, ¿qué significa para ti "se recomienda"? no hay una persona suprema que recomiende o apruebe. Se trata del uso de un motor de expresión regular en php que es un agujero negro en el lenguaje en sí, es posible que desee intentar poner una coincidencia de expresiones regulares en un bucle y comparar los resultados. - Decebal

Esta respuesta está mal demostrada y falla con muchos escenarios extendidos. No veo ningún beneficio en practicar esta técnica. Aquí está la función personalizada refinada y la llamada iterada: 3v4l.org/E9dfD No tengo ningún interés en editar este wiki porque considero que es una pérdida de tiempo para los investigadores. - mickmackusa

Muchas respuestas que usan substr_count comprueba si el resultado es >0. Pero desde el if declaración considera cero el igual que falso, puede evitar ese cheque y escribir directamente:

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

Para verificar si no presente, agregue el ! operador:

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

Respondido el 21 de diciembre de 17 a las 11:12

Bueno ... parcialmente cierto, en php 0 == falso es cierto, pero 0 === falso es falso - Andrejs Gubars

Otra opción para encontrar la ocurrencia de una palabra de una cadena usando strstr () y stristr () es como el siguiente:

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

Respondido el 25 de junio de 16 a las 20:06

Esto es al revés. La i in stristr significa insensible. - adam merrifield

Se puede realizar de tres formas distintas:

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

Respondido el 28 de diciembre de 15 a las 04:12

bueno, pero preg_match es arriesgado ya que puede devolver falso o 0. Debería estar probando === 1 en # 3 - Shapeshifter

La versión abreviada

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

respondido 20 mar '16, 17:03

Si bien este fragmento de código puede resolver la pregunta, incluyendo una explicación realmente ayuda a mejorar la calidad de tu publicación. Recuerde que está respondiendo a la pregunta para los lectores en el futuro, y es posible que esas personas no conozcan los motivos de su sugerencia de código. - Bono

Para encontrar una 'palabra', en lugar de la aparición de una serie de letras que de hecho podrían ser parte de otra palabra, la siguiente sería una buena solución.

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

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

Respondido el 25 de junio de 16 a las 20:06

fallará si $string is Are are, are? - Soleada

Debe usar el formato insensible a mayúsculas y minúsculas, por lo que si el valor ingresado está en small or caps no 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";
}
?>

Aquí stripos encuentra aguja en heystack sin considerando el caso (small / caps).

Muestra PHPCode con salida

Respondido el 08 de Septiembre de 15 a las 12:09

Quizás podrías usar algo como esto:

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

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

Respondido el 25 de junio de 16 a las 20:06

No utilice preg_match() si solo desea verificar si una cadena está contenida en otra cadena. Usar strpos() or strstr() en cambio, ya que serán más rápidos. (http://in2.php.net/preg_match)

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

Respondido 05 Abr '14, 12:04

Si desea verificar si la cadena contiene varias palabras específicas, puede hacer lo siguiente:

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

Esto es útil para evitar el spam al enviar correos electrónicos, por ejemplo.

Respondido el 25 de junio de 16 a las 20:06

La función strpos funciona bien, pero si quieres hacer case-insensitive buscando una palabra en un párrafo, puede hacer uso de la stripos función de PHP.

Por ejemplo, los servicios administrativos de

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

Encuentre la posición de la primera aparición de una subcadena que no distingue entre mayúsculas y minúsculas en una cadena.

Si la palabra no existe en la cadena, devolverá falso; de lo contrario, devolverá la posición de la palabra.

Respondido el 05 de enero de 17 a las 14:01

Debe usar operadores idénticos / no idénticos porque strpos puede devolver 0 como valor de índice. Si le gustan los operadores ternarios, considere usar lo siguiente (parece un poco al revés, lo admito):

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

Respondido 21 Feb 16, 18:02

¿Compruebe si la cadena contiene palabras específicas?

Esto significa que la cadena debe resolverse en palabras (consulte la nota a continuación).

Una forma de hacer esto y especificar los separadores es usando preg_split (doctor):

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

?>

Una carrera da

$ 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: Aquí no queremos decir palabra para cada secuencia de símbolos.

Una definición práctica de palabra es en el sentido del motor de expresión regular PCRE, donde las palabras son subcadenas que constan únicamente de caracteres de palabra, separadas por caracteres que no son palabras.

Un carácter de "palabra" es cualquier letra o dígito o el carácter de subrayado, es decir, cualquier carácter que pueda formar parte de una "palabra" de Perl. La definición de letras y dígitos está controlada por las tablas de caracteres de PCRE, y puede variar si se lleva a cabo una coincidencia específica de la localidad (..)

Respondido el 24 de Septiembre de 15 a las 00:09

Uso:

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

Respondido el 25 de junio de 16 a las 20:06

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.