zeichen - search for string php




Wie überprüfe ich, ob eine Zeichenfolge ein bestimmtes Wort enthält? (20)

Prüfen Sie, ob der String bestimmte Wörter enthält.

Dies bedeutet, dass die Zeichenfolge in Wörter aufgelöst werden muss (siehe Hinweis unten).

Eine Möglichkeit, dies zu tun und die Trennzeichen anzugeben, ist preg_split ( doc ):

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

Ein Lauf gibt

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

?>

Hinweis: Hier meinen wir nicht Wort für jede Folge von Symbolen.

Eine praktische Definition von Wort ist die PCRE-Engine für reguläre Ausdrücke, bei der Wörter Teilzeichenfolgen sind, die nur aus Wortzeichen bestehen und durch Nichtwortzeichen getrennt sind.

Ein "Wort" -Zeichen ist ein Buchstabe, eine Ziffer oder der Unterstrich, dh jedes Zeichen, das Teil eines Perl- "Worts" sein kann. Die Definition von Buchstaben und Ziffern wird durch die Zeichentabellen von PCRE gesteuert und kann variieren, wenn ein ländereinstellungsspezifischer Abgleich stattfindet (..)

Erwägen:

$a = 'How are you?';

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

Angenommen, ich habe den obigen Code. Wie schreibt man die Anweisung richtig, if ($a contains 'are') ?


Die Kurzhandversion

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

Die folgende Funktion funktioniert auch und hängt von keiner anderen Funktion ab. es verwendet nur native PHP-String-Manipulation. Ich persönlich empfehle das nicht, aber Sie können sehen, wie es funktioniert:

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

Prüfung:

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 

Eine andere Möglichkeit, das Vorkommen eines Wortes aus einer Zeichenfolge mithilfe von strstr() und stristr() folgendermaßen aus:

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

Es gibt drei verschiedene Möglichkeiten:

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

Hier ist eine kleine Hilfsfunktion, die in solchen Situationen nützlich ist

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

Ich hatte einige Probleme damit und entschied mich schließlich für meine eigene Lösung. Ohne reguläre Ausdrücke zu verwenden:

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öglicherweise stellen Sie fest, dass die vorherigen Lösungen keine Antwort auf das Wort sind, das als Präfix für ein anderes verwendet wird. Um Ihr Beispiel zu verwenden:

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

In den obigen Beispielen enthalten sowohl $a als auch $b $c , aber Sie möchten vielleicht, dass Ihre Funktion Ihnen mitteilt, dass nur $a $c enthält.


In PHP können Sie am besten überprüfen, ob eine Zeichenfolge eine bestimmte Teilzeichenfolge enthält, indem Sie eine einfache Hilfsfunktion wie die folgende verwenden:

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

Erläuterung:

  • strpos() die Position des ersten Vorkommens einer Groß- / Kleinschreibung in einer Zeichenfolge.
  • stripos() die Position des ersten Vorkommens einer stripos() , die nicht zwischen Groß- und Kleinschreibung unterscheidet, in einer Zeichenfolge.
  • myFunction($haystack, $needle) === FALSE ? FALSE : TRUE myFunction($haystack, $needle) === FALSE ? FALSE : TRUE stellt sicher, dass myFunction immer einen Boolean- myFunction zurückgibt und unerwartetes Verhalten behebt, wenn der Index des Teilstrings 0 ist.
  • $caseSensitive ? A : B $caseSensitive ? A : B wählt je nach Wert von $caseSensitive entweder strpos() oder $caseSensitive .

Ausgabe:

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)

Sie können die strpos() Funktion verwenden, um das Vorkommen einer Zeichenfolge in einer anderen zu finden:

$a = 'How are you?';

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

Beachten Sie, dass die Verwendung von !== false absichtlich ist. strpos() gibt entweder den Offset zurück, bei dem die strpos() in der Heuhaufenkette beginnt, oder den booleschen Wert false wenn die Nadel nicht gefunden wird. Da 0 ein gültiger Offset ist und 0 "Falsey" ist, können wir keine einfacheren Konstrukte wie !strpos($a, 'are') .


Sie können die Funktion strstr verwenden:

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

if ($flag){

    echo "true";
}

Ohne eingebaute Funktion:

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

Sie müssen identische / nicht identische Operatoren verwenden, da strpos als Indexwert 0 zurückgeben kann. Wenn Sie ternäre Operatoren mögen, sollten Sie Folgendes in Betracht ziehen (scheint etwas rückwärts zu sein, gebe ich zu):

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

Sie sollten das case insensitive Format verwenden. Wenn der eingegebene Wert in small oder caps es unwichtig.

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

Hier findet stripos die Nadel im Heystack, ohne dabei auf den Fall (klein / klein) zu achten.

PHPCode-Beispiel mit Ausgabe


Um festzustellen, ob eine Zeichenfolge eine andere Zeichenfolge enthält, können Sie die PHP-Funktion 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";
}

?>

VORSICHT:

Befindet sich die Nadel, nach der Sie suchen, am Anfang des Heuhakens, wird sie auf Position 0 zurückgesetzt. Wenn Sie einen Vergleich durchführen, der nicht funktioniert, müssen Sie den ===

Ein == Zeichen ist ein Vergleich und prüft, ob die Variable / Ausdruck / Konstante links denselben Wert hat wie die Variable / Ausdruck / Konstante rechts.

Ein === Zeichen ist ein Vergleich, um zu sehen, ob zwei Variablen / Ausdrücke / Konstanten gleich sind AND den gleichen Typ haben - dh beide sind Strings oder beide Ganzzahlen.


Verwenden Sie preg_match() wenn Sie nur prüfen möchten, ob eine Zeichenfolge in einer anderen Zeichenfolge enthalten ist. Verwenden strpos() stattdessen strpos() oder strstr() da sie schneller sind. ( http://in2.php.net/preg_match )

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

Vielleicht könnten Sie so etwas verwenden:

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

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

Während die meisten dieser Antworten Ihnen sagen, ob eine Teilzeichenfolge in Ihrer Zeichenfolge angezeigt wird, ist dies normalerweise nicht das, was Sie möchten, wenn Sie nach einem bestimmten Wort und nicht nach einer Teilzeichenfolge suchen.

Was ist der Unterschied? Substrate können mit anderen Worten auftreten:

  • Die "sind" am Anfang von "Bereich"
  • Die "sind" am Ende von "Hase"
  • Die "sind" in der Mitte der "Tarife"

Eine Möglichkeit, dies zu mildern, wäre die Verwendung eines regulären Ausdrucks in Verbindung mit Wortgrenzen ( \b ):

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

Diese Methode hat nicht die gleichen falschen Positiven wie oben erwähnt, aber sie hat einige Randfälle. Wortgrenzen stimmen mit Nicht-Wort-Zeichen ( \W ) überein. Dabei handelt es sich um alles, was nicht az , AZ , 0-9 oder _ . Das bedeutet, dass Ziffern und Unterstriche als Wortzeichen gezählt werden und Szenarien wie dieses versagen:

  • Die "sind" in "Was denkst du?"
  • Die "sind" in "lol u weißt du nicht, ob die 4 sind?"

Wenn Sie etwas genaueres wollen, müssen Sie mit der Syntaxanalyse in englischer Sprache beginnen, und das ist eine ziemlich große Anzahl von Würmern (und setzt voraus, dass die Syntax sowieso verwendet wird, was nicht immer gegeben ist).


Wenn Sie prüfen möchten, ob die Zeichenfolge mehrere bestimmte Wörter enthält, können Sie Folgendes tun:

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

Dies ist nützlich, um beispielsweise beim Versenden von E-Mails Spam zu vermeiden.


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

Eine Zeichenfolge kann mit der folgenden Funktion überprüft werden:

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

Die strpos-Funktion funktioniert einwandfrei. Wenn Sie jedoch case-insensitivenach einem Wort in einem Absatz suchen möchten, können Sie die striposFunktion von verwenden PHP.

Zum Beispiel,

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

Ermitteln Sie die Position des ersten Vorkommens einer Zeichenfolge, bei der die Groß- / Kleinschreibung nicht beachtet wird.

Wenn das Wort in der Zeichenfolge nicht vorhanden ist, wird false zurückgegeben. Andernfalls wird die Position des Wortes zurückgegeben.





string-matching