Wie kann ich zwei Funktionen schreiben, die eine Zeichenfolge annehmen und zurückgeben, wenn sie mit dem angegebenen Zeichen / der angegebenen Zeichenfolge beginnt oder damit endet?

Zum Beispiel:

$str = '|apples}';

echo startsWith($str, '|'); //Returns true
echo endsWith($str, '}'); //Returns true

function startsWith($haystack, $needle)
{
     $length = strlen($needle);
     return (substr($haystack, 0, $length) === $needle);
}

function endsWith($haystack, $needle)
{
    $length = strlen($needle);
    if ($length == 0) {
        return true;
    }

    return (substr($haystack, -$length) === $needle);
}

Verwenden Sie diese Option, wenn Sie keinen regulären Ausdruck verwenden möchten.

Mit der substr_compareFunktion können Sie Anfang und Ende überprüfen mit:

function startsWith($haystack, $needle) {
    return substr_compare($haystack, $needle, 0, strlen($needle)) === 0;
}
function endsWith($haystack, $needle) {
    return substr_compare($haystack, $needle, -strlen($needle)) === 0;
}

^{Dies sollte eine der schnellsten Lösungen für PHP 7 ( Benchmark-Skript ) sein. Getestet gegen 8KB Heuhaufen, Nadeln unterschiedlicher Länge und volle, teilweise und keine Streichhölzer. strncmpist für Anfänge eine Berührung schneller, kann aber die Enden nicht überprüfen.}

Aktualisiert am 23.08.2016

Funktionen

function substr_startswith($haystack, $needle) {
    return substr($haystack, 0, strlen($needle)) === $needle;
}

function preg_match_startswith($haystack, $needle) {
    return preg_match('~' . preg_quote($needle, '~') . '~A', $haystack) > 0;
}

function substr_compare_startswith($haystack, $needle) {
    return substr_compare($haystack, $needle, 0, strlen($needle)) === 0;
}

function strpos_startswith($haystack, $needle) {
    return strpos($haystack, $needle) === 0;
}

function strncmp_startswith($haystack, $needle) {
    return strncmp($haystack, $needle, strlen($needle)) === 0;
}

function strncmp_startswith2($haystack, $needle) {
    return $haystack[0] === $needle[0]
        ? strncmp($haystack, $needle, strlen($needle)) === 0
        : false;
}

Tests

echo 'generating tests';
for($i = 0; $i < 100000; ++$i) {
    if($i % 2500 === 0) echo '.';
    $test_cases[] = [
        random_bytes(random_int(1, 7000)),
        random_bytes(random_int(1, 3000)),
    ];
}
echo "done!\n";


$functions = ['substr_startswith', 'preg_match_startswith', 'substr_compare_startswith', 'strpos_startswith', 'strncmp_startswith', 'strncmp_startswith2'];
$results = [];

foreach($functions as $func) {
    $start = microtime(true);
    foreach($test_cases as $tc) {
        $func(...$tc);
    }
    $results[$func] = (microtime(true) - $start) * 1000;
}

asort($results);

foreach($results as $func => $time) {
    echo "$func: " . number_format($time, 1) . " ms\n";
}

Ergebnisse (PHP 7.0.9)

(Am schnellsten bis am langsamsten sortiert)

strncmp_startswith2: 40.2 ms
strncmp_startswith: 42.9 ms
substr_compare_startswith: 44.5 ms
substr_startswith: 48.4 ms
strpos_startswith: 138.7 ms
preg_match_startswith: 13,152.4 ms

Ergebnisse (PHP 5.3.29)

(Am schnellsten bis am langsamsten sortiert)

strncmp_startswith2: 477.9 ms
strpos_startswith: 522.1 ms
strncmp_startswith: 617.1 ms
substr_compare_startswith: 706.7 ms
substr_startswith: 756.8 ms
preg_match_startswith: 10,200.0 ms

Starts mit_benchmark.php

So weit Alle Antworten Lasten unnötiger Arbeit zu tun scheinen, strlen calculations, string allocations (substr)usw. Das 'strpos'und 'stripos'Funktionen geben den Index des ersten Auftretens $needlein $haystack:

function startsWith($haystack,$needle,$case=true)
{
    if ($case)
        return strpos($haystack, $needle, 0) === 0;

    return stripos($haystack, $needle, 0) === 0;
}

function endsWith($haystack,$needle,$case=true)
{
    $expectedPosition = strlen($haystack) - strlen($needle);

    if ($case)
        return strrpos($haystack, $needle, 0) === $expectedPosition;

    return strripos($haystack, $needle, 0) === $expectedPosition;
}

function startsWith($haystack, $needle, $case = true) {
    if ($case) {
        return (strcmp(substr($haystack, 0, strlen($needle)), $needle) === 0);
    }
    return (strcasecmp(substr($haystack, 0, strlen($needle)), $needle) === 0);
}

function endsWith($haystack, $needle, $case = true) {
    if ($case) {
        return (strcmp(substr($haystack, strlen($haystack) - strlen($needle)), $needle) === 0);
    }
    return (strcasecmp(substr($haystack, strlen($haystack) - strlen($needle)), $needle) === 0);
}

Gutschrift an :

Überprüfen Sie, ob eine Zeichenfolge mit einer anderen Zeichenfolge endet

Überprüfen Sie, ob eine Zeichenfolge mit einer anderen Zeichenfolge beginnt

Der Regex funktioniert oben, aber mit den anderen oben ebenfalls vorgeschlagenen Verbesserungen:

 function startsWith($needle, $haystack) {
     return preg_match('/^' . preg_quote($needle, '/') . '/', $haystack);
 }

 function endsWith($needle, $haystack) {
     return preg_match('/' . preg_quote($needle, '/') . '$/', $haystack);
 }

Diese Frage hat bereits viele Antworten, aber in einigen Fällen können Sie sich mit etwas Einfacherem als allen zufrieden geben. Wenn die gesuchte Zeichenfolge bekannt ist (fest codiert), können Sie reguläre Ausdrücke ohne Anführungszeichen usw. verwenden.

Überprüfen Sie, ob eine Zeichenfolge mit 'ABC' beginnt:

preg_match('/^ABC/', $myString); // "^" here means beginning of string

endet mit 'ABC':

preg_match('/ABC$/', $myString); // "$" here means end of string

In meinem einfachen Fall wollte ich überprüfen, ob eine Zeichenfolge mit einem Schrägstrich endet:

preg_match('#/$#', $myPath);   // Use "#" as delimiter instead of escaping slash

Der Vorteil: Da es sehr kurz und einfach ist, müssen Sie keine Funktion definieren (z endsWith() ) wie oben gezeigt definieren.

Aber nochmal - dies ist nicht für jeden Fall eine Lösung, nur für diesen sehr spezifischen.

Wenn Geschwindigkeit für Sie wichtig ist, versuchen Sie dies (ich glaube, es ist die schnellste Methode)

Funktioniert nur für Strings und wenn $ haystack nur 1 Zeichen ist

function startsWithChar($needle, $haystack)
{
   return ($needle[0] === $haystack);
}

function endsWithChar($needle, $haystack)
{
   return ($needle[strlen($needle) - 1] === $haystack);
}

$str='|apples}';
echo startsWithChar($str,'|'); //Returns true
echo endsWithChar($str,'}'); //Returns true
echo startsWithChar($str,'='); //Returns false
echo endsWithChar($str,'#'); //Returns false

Hier sind zwei Funktionen, die keine temporäre Zeichenfolge einführen. Dies kann nützlich sein, wenn die Nadeln sehr groß sind:

function startsWith($haystack, $needle)
{
    return strncmp($haystack, $needle, strlen($needle)) === 0;
}

function endsWith($haystack, $needle)
{
    return $needle === '' || substr_compare($haystack, $needle, -strlen($needle)) === 0;
}

Schnellste EndenWith () Lösung:

# Checks if a string ends in a string
function endsWith($haystack, $needle) {
    return substr($haystack,-strlen($needle))===$needle;
}

Benchmark:

# This answer
function endsWith($haystack, $needle) {
    return substr($haystack,-strlen($needle))===$needle;
}

# Accepted answer
function endsWith2($haystack, $needle) {
    $length = strlen($needle);

    return $length === 0 ||
    (substr($haystack, -$length) === $needle);
}

# Second most-voted answer
function endsWith3($haystack, $needle) {
    // search forward starting from end minus needle length characters
    if ($needle === '') {
        return true;
    }
    $diff = \strlen($haystack) - \strlen($needle);
    return $diff >= 0 && strpos($haystack, $needle, $diff) !== false;
}

# Regex answer
function endsWith4($haystack, $needle) {
    return preg_match('/' . preg_quote($needle, '/') . '$/', $haystack);
}

function timedebug() {
    $test = 10000000;

    $time1 = microtime(true);
    for ($i=0; $i < $test; $i++) {
        $tmp = endsWith('TestShortcode', 'Shortcode');
    }
    $time2 = microtime(true);
    $result1 = $time2 - $time1;

    for ($i=0; $i < $test; $i++) {
        $tmp = endsWith2('TestShortcode', 'Shortcode');
    }
    $time3 = microtime(true);
    $result2 = $time3 - $time2;

    for ($i=0; $i < $test; $i++) {
        $tmp = endsWith3('TestShortcode', 'Shortcode');
    }
    $time4 = microtime(true);
    $result3 = $time4 - $time3;

    for ($i=0; $i < $test; $i++) {
        $tmp = endsWith4('TestShortcode', 'Shortcode');
    }
    $time5 = microtime(true);
    $result4 = $time5 - $time4;

    echo $test.'x endsWith: '.$result1.' seconds # This answer<br>';
    echo $test.'x endsWith2: '.$result4.' seconds # Accepted answer<br>';
    echo $test.'x endsWith3: '.$result2.' seconds # Second most voted answer<br>';
    echo $test.'x endsWith4: '.$result3.' seconds # Regex answer<br>';
    exit;
}
timedebug();

Benchmark-Ergebnisse:

10000000x endsWith: 1.5760900974274 seconds # This answer
10000000x endsWith2: 3.7102129459381 seconds # Accepted answer
10000000x endsWith3: 1.8731069564819 seconds # Second most voted answer
10000000x endsWith4: 2.1521229743958 seconds # Regex answer

Mir ist klar, dass dies abgeschlossen ist, aber Sie können sich strncmp ansehen, da Sie so die Länge der Zeichenfolge zum Vergleichen angeben können.

function startsWith($haystack, $needle, $case=true) {
    if ($case)
        return strncasecmp($haystack, $needle, strlen($needle)) == 0;
    else
        return strncmp($haystack, $needle, strlen($needle)) == 0;
}    

Sie können strposund verwendenstrrpos

$bStartsWith = strpos($sHaystack, $sNeedle) == 0;
$bEndsWith = strrpos($sHaystack, $sNeedle) == strlen($sHaystack)-strlen($sNeedle);

Hier ist eine Multi-Byte-sichere Version der akzeptierten Antwort. Sie funktioniert gut für UTF-8-Zeichenfolgen:

function startsWith($haystack, $needle)
{
    $length = mb_strlen($needle, 'UTF-8');
    return (mb_substr($haystack, 0, $length, 'UTF-8') === $needle);
}

function endsWith($haystack, $needle)
{
    $length = mb_strlen($needle, 'UTF-8');
    return $length === 0 ||
        (mb_substr($haystack, -$length, $length, 'UTF-8') === $needle);
}

Kurze und leicht verständliche Einzeiler ohne reguläre Ausdrücke.

startWith () ist unkompliziert.

function startsWith($haystack, $needle) {
   return (strpos($haystack, $needle) === 0);
}

EndenWith () verwendet das etwas ausgefallene und langsame strrev ():

function endsWith($haystack, $needle) {
   return (strpos(strrev($haystack), strrev($needle)) === 0);
}

Wenn Sie sich auf startwith konzentrieren und sicher sind, dass die Zeichenfolgen nicht leer sind, beschleunigt das Hinzufügen eines Tests für das erste Zeichen vor dem Vergleich, die Zeichenfolge usw. die Dinge ein wenig:

function startswith5b($haystack, $needle) {
    return ($haystack{0}==$needle{0})?strncmp($haystack, $needle, strlen($needle)) === 0:FALSE;
}

Es ist irgendwie (20% -30%) schneller. Das Hinzufügen eines weiteren Char-Tests wie $ haystack {1} === $ Needle {1} scheint die Dinge nicht wesentlich zu beschleunigen, kann sogar langsamer werden.

===scheint schneller als == Bedingter Operator (a)?b:cscheint schneller alsif(a) b; else c;

Für diejenigen, die fragen: "Warum nicht Strpos verwenden?" andere Lösungen als "unnötige Arbeit" bezeichnen

strpos ist schnell, aber nicht das richtige Werkzeug für diesen Job.

Zum Verständnis hier eine kleine Simulation als Beispiel:

Search a12345678c inside bcdefga12345678xbbbbb.....bbbbba12345678c

Was macht der Computer "drinnen"?

    With strccmp, etc...

    is a===b? NO
    return false



    With strpos

    is a===b? NO -- iterating in haysack
    is a===c? NO
    is a===d? NO
    ....
    is a===g? NO
    is a===g? NO
    is a===a? YES
    is 1===1? YES -- iterating in needle
    is 2===3? YES
    is 4===4? YES
    ....
    is 8===8? YES
    is c===x? NO: oh God,
    is a===1? NO -- iterating in haysack again
    is a===2? NO
    is a===3? NO
    is a===4? NO
    ....
    is a===x? NO
    is a===b? NO
    is a===b? NO
    is a===b? NO
    is a===b? NO
    is a===b? NO
    is a===b? NO
    is a===b? NO
    ...
    ... may many times...
    ...
    is a===b? NO
    is a===a? YES -- iterating in needle again
    is 1===1? YES
    is 2===3? YES
    is 4===4? YES
    is 8===8? YES
    is c===c? YES YES YES I have found the same string! yay!
    was it at position 0? NOPE
    What you mean NO? So the string I found is useless? YEs.
    Damn.
    return false

Angenommen, strlen iteriert nicht die gesamte Zeichenfolge (aber selbst in diesem Fall) ist dies überhaupt nicht praktisch.

Ich hoffe, dass die folgende Antwort effizient und auch einfach sein kann:

$content = "The main string to search";
$search = "T";
//For compare the begining string with case insensitive. 
if(stripos($content, $search) === 0) echo 'Yes';
else echo 'No';

//For compare the begining string with case sensitive. 
if(strpos($content, $search) === 0) echo 'Yes';
else echo 'No';

//For compare the ending string with case insensitive. 
if(stripos(strrev($content), strrev($search)) === 0) echo 'Yes';
else echo 'No';

//For compare the ending string with case sensitive. 
if(strpos(strrev($content), strrev($search)) === 0) echo 'Yes';
else echo 'No';

Normalerweise gehe ich heutzutage mit einer Bibliothek wie underscore-php .

require_once("vendor/autoload.php"); //use if needed
use Underscore\Types\String; 

$str = "there is a string";
echo( String::startsWith($str, 'the') ); // 1
echo( String::endsWith($str, 'ring')); // 1   

Die Bibliothek ist voll von anderen praktischen Funktionen.

Die Antwort von mpen ist unglaublich gründlich, aber leider hat der bereitgestellte Benchmark eine sehr wichtige und nachteilige Kontrolle.

Da jedes Byte in Nadeln und Heuhaufen völlig zufällig ist, beträgt die Wahrscheinlichkeit, dass sich ein Nadel-Heuhaufen-Paar im ersten Byte unterscheidet, 99,609375%, was bedeutet, dass sich im Durchschnitt etwa 99609 der 100000 Paare im ersten Byte unterscheiden . Mit anderen Worten, der Benchmark ist stark auf startswithImplementierungen ausgerichtet, die das erste Byte explizit prüfen, wie zstrncmp_startswith2 .

Wenn die Testgenerierungsschleife stattdessen wie folgt implementiert wird:

echo 'generating tests';
for($i = 0; $i < 100000; ++$i) {
    if($i % 2500 === 0) echo '.';

    $haystack_length = random_int(1, 7000);
    $haystack = random_bytes($haystack_length);

    $needle_length = random_int(1, 3000);
    $overlap_length = min(random_int(0, $needle_length), $haystack_length);
    $needle = ($needle_length > $overlap_length) ?
        substr($haystack, 0, $overlap_length) . random_bytes($needle_length - $overlap_length) :
        substr($haystack, 0, $needle_length);

    $test_cases[] = [$haystack, $needle];
}
echo " done!<br />";

Die Benchmark-Ergebnisse erzählen eine etwas andere Geschichte:

strncmp_startswith: 223.0 ms
substr_startswith: 228.0 ms
substr_compare_startswith: 238.0 ms
strncmp_startswith2: 253.0 ms
strpos_startswith: 349.0 ms
preg_match_startswith: 20,828.7 ms

Natürlich ist dieser Benchmark möglicherweise noch nicht vollkommen unvoreingenommen, aber er testet die Effizienz der Algorithmen, wenn auch teilweise passende Nadeln gegeben werden.

Zusamenfassend:

function startsWith($str, $needle){
   return substr($str, 0, strlen($needle)) === $needle;
}

function endsWith($str, $needle){
   $length = strlen($needle);
   return !$length || substr($str, - $length) === $needle;
}

Nur eine Empfehlung:

function startsWith($haystack,$needle) {
    if($needle==="") return true;
    if($haystack[0]<>$needle[0]) return false; // ------------------------- speed boost!
    return (0===substr_compare($haystack,$needle,0,strlen($needle)));
}

Diese zusätzliche Zeile, in der das erste Zeichen der Zeichenfolgen verglichen wird, kann dazu führen, dass der falsche Fall sofort zurückkehrt , wodurch viele Ihrer Vergleiche viel schneller werden (7x schneller, wenn ich gemessen habe). Im wahren Fall zahlen Sie für diese einzelne Leitung praktisch keinen Preis für die Leistung, daher denke ich, dass es sich lohnt, sie einzubeziehen. (In der Praxis schlagen die meisten Vergleiche fehl, wenn Sie viele Zeichenfolgen auf einen bestimmten Startblock testen, da Sie in einem typischen Fall nach etwas suchen.)

Die substrFunktion kann falsein vielen Sonderfällen zurückgegeben werden. Hier ist meine Version, die sich mit folgenden Problemen befasst:

function startsWith( $haystack, $needle ){
  return $needle === ''.substr( $haystack, 0, strlen( $needle )); // substr's false => empty string
}

function endsWith( $haystack, $needle ){
  $len = strlen( $needle );
  return $needle === ''.substr( $haystack, -$len, $len ); // ! len=0
}

Tests ( truebedeutet gut):

var_dump( startsWith('',''));
var_dump( startsWith('1',''));
var_dump(!startsWith('','1'));
var_dump( startsWith('1','1'));
var_dump( startsWith('1234','12'));
var_dump(!startsWith('1234','34'));
var_dump(!startsWith('12','1234'));
var_dump(!startsWith('34','1234'));
var_dump('---');
var_dump( endsWith('',''));
var_dump( endsWith('1',''));
var_dump(!endsWith('','1'));
var_dump( endsWith('1','1'));
var_dump(!endsWith('1234','12'));
var_dump( endsWith('1234','34'));
var_dump(!endsWith('12','1234'));
var_dump(!endsWith('34','1234'));

Auch die substr_compareFunktion ist einen Blick wert. http://www.php.net/manual/en/function.substr-compare.php

Dies kann funktionieren

function startsWith($haystack, $needle) {
     return substr($haystack, 0, strlen($needle)) == $needle;
}

Quelle: https://stackoverflow.com/a/4419658

Ich würde es so machen

     function startWith($haystack,$needle){
              if(substr($haystack,0, strlen($needle))===$needle)
              return true;
        }

  function endWith($haystack,$needle){
              if(substr($haystack, -strlen($needle))===$needle)
              return true;
        }

Basierend auf der Antwort von James Black ist hier das Ende mit der Version:

function startsWith($haystack, $needle, $case=true) {
    if ($case)
        return strncmp($haystack, $needle, strlen($needle)) == 0;
    else
        return strncasecmp($haystack, $needle, strlen($needle)) == 0;
}

function endsWith($haystack, $needle, $case=true) {
     return startsWith(strrev($haystack),strrev($needle),$case);

}

Hinweis: Ich habe den if-else-Teil gegen James Blacks Funktion "DoesWith" ausgetauscht, da strncasecmp die Version von strncmp ist, bei der die Groß- und Kleinschreibung nicht berücksichtigt wird.

Warum nicht das Folgende?

//How to check if a string begins with another string
$haystack = "valuehaystack";
$needle = "value";
if (strpos($haystack, $needle) === 0){
    echo "Found " . $needle . " at the beginning of " . $haystack . "!";
}

Ausgabe:

Wert zu Beginn des Valueehaystacks gefunden!

Beachten Sie, strposdass false zurückgegeben wird, wenn die Nadel nicht im Heuhaufen gefunden wurde, und 0 zurückgegeben wird, wenn und nur wenn die Nadel bei Index 0 gefunden wurde (AKA am Anfang).

Und hier endet mit:

$haystack = "valuehaystack";
$needle = "haystack";

//If index of the needle plus the length of the needle is the same length as the entire haystack.
if (strpos($haystack, $needle) + strlen($needle) === strlen($haystack)){
    echo "Found " . $needle . " at the end of " . $haystack . "!";
}

In diesem Szenario ist keine Funktion startWith () as erforderlich

(strpos($stringToSearch, $doesItStartWithThis) === 0)

wird wahr oder falsch genau zurückgeben.

Es scheint seltsam, dass es so einfach ist, wenn all die wilden Funktionen hier weit verbreitet sind.

Viele der vorherigen Antworten werden genauso gut funktionieren. Dies ist jedoch möglicherweise so kurz, wie Sie es schaffen und es tun lassen können, was Sie wollen. Sie geben nur an, dass Sie möchten, dass es "true" zurückgibt. Daher habe ich Lösungen eingefügt, die boolesches true / false und textuelles true / false zurückgeben.

// boolean true/false
function startsWith($haystack, $needle)
{
    return strpos($haystack, $needle) === 0 ? 1 : 0;
}

function endsWith($haystack, $needle)
{
    return stripos($haystack, $needle) === 0 ? 1 : 0;
}


// textual true/false
function startsWith($haystack, $needle)
{
    return strpos($haystack, $needle) === 0 ? 'true' : 'false';
}

function endsWith($haystack, $needle)
{
    return stripos($haystack, $needle) === 0 ? 'true' : 'false';
}

Sie können auch reguläre Ausdrücke verwenden:

function endsWith($haystack, $needle, $case=true) {
  return preg_match("/.*{$needle}$/" . (($case) ? "" : "i"), $haystack);
}

No-Copy und No-Intern-Loop:

function startsWith(string $string, string $start): bool
{
    return strrpos($string, $start, - strlen($string)) !== false;
}

function endsWith(string $string, string $end): bool
{
    return ($offset = strlen($string) - strlen($end)) >= 0 
    && strpos($string, $end, $offset) !== false;
}

Hier ist eine effiziente Lösung für PHP 4. Sie könnten schnellere Ergebnisse erzielen, wenn Sie PHP 5 substr_compareanstelle von verwenden strcasecmp(substr(...)).

function stringBeginsWith($haystack, $beginning, $caseInsensitivity = false)
{
    if ($caseInsensitivity)
        return strncasecmp($haystack, $beginning, strlen($beginning)) === 0;
    else
        return strncmp($haystack, $beginning, strlen($beginning)) === 0;
}

function stringEndsWith($haystack, $ending, $caseInsensitivity = false)
{
    if ($caseInsensitivity)
        return strcasecmp(substr($haystack, strlen($haystack) - strlen($ending)), $haystack) === 0;
    else
        return strpos($haystack, $ending, strlen($haystack) - strlen($ending)) !== false;
}

Hierfür können Sie die Funktion fnmatch verwenden.

// Starts with.
fnmatch('prefix*', $haystack);
// Ends with.
fnmatch('*suffix', $haystack);