Jak napisać dwie funkcje, które pobiorą ciąg i zwrócą go, jeśli zaczyna się od określonego znaku / ciągu lub kończy się na nim?

Na przykład:

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

Użyj tego, jeśli nie chcesz używać wyrażenia regularnego.

Możesz użyć substr_comparefunkcji, aby sprawdzić początek i koniec:

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

^{To powinno być jedno z najszybszych rozwiązań na PHP 7 ( skrypt porównawczy ). Testowany na stogach siana o pojemności 8 KB, różnych długościach igieł oraz pełnych, częściowych i niepasujących skrzyniach. strncmpjest odrobinę szybszy na początku, ale nie może sprawdzić końca.}

Zaktualizowano 23 sierpnia 2016 r

Funkcje

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

Testy

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

Wyniki (PHP 7.0.9)

(Posortowane od najszybszego do najwolniejszego)

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

Wyniki (PHP 5.3.29)

(Posortowane od najszybszego do najwolniejszego)

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

openswith_benchmark.php

Wszystkie odpowiedzi do tej pory wydaje się robić mnóstwo niepotrzebnej pracy strlen calculations, string allocations (substr)itp 'strpos'i 'stripos'zwracają indeks pierwszego wystąpienia $needlew $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);
}

Kredyt dla :

Sprawdź, czy łańcuch kończy się innym łańcuchem

Sprawdź, czy ciąg zaczyna się od innego ciągu

Wyrażenia regularne działają powyżej, ale z innymi poprawkami również sugerowanymi powyżej:

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

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

To pytanie ma już wiele odpowiedzi, ale w niektórych przypadkach możesz zadowolić się czymś prostszym niż wszystkie. Jeśli ciąg, którego szukasz, jest znany (zakodowany na stałe), możesz używać wyrażeń regularnych bez cudzysłowu itp.

Sprawdź, czy ciąg zaczyna się od „ABC”:

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

kończy się na „ABC”:

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

W moim prostym przypadku chciałem sprawdzić, czy ciąg kończy się ukośnikiem:

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

Zaleta: ponieważ jest bardzo krótka i prosta, nie trzeba definiować funkcji (takich jak endsWith()), jak pokazano powyżej.

Ale znowu - to nie jest rozwiązanie dla każdego przypadku, tylko ten bardzo konkretny.

Jeśli prędkość jest dla Ciebie ważna, spróbuj tego (uważam, że jest to najszybsza metoda)

Działa tylko dla ciągów znaków i jeśli $ stóg siana ma tylko 1 znak

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

Oto dwie funkcje, które nie wprowadzają tymczasowego ciągu, które mogą być przydatne, gdy igły są znacznie duże:

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

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

Najszybsze rozwiązanie Rozwiązanie ():

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

Reper:

# 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();

Wyniki testu:

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

Zdaję sobie sprawę, że zostało to zakończone, ale możesz chcieć spojrzeć na strncmp, ponieważ pozwala on ustawić długość łańcucha do porównania, więc:

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

Możesz użyć strposistrrpos

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

Oto wielobajtowa bezpieczna wersja zaakceptowanej odpowiedzi, działa dobrze dla ciągów UTF-8:

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

Krótkie i łatwe do zrozumienia jedno-linijki bez wyrażeń regularnych.

StartWith () jest prosty.

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

EndWith () używa nieco fantazyjnego i wolnego strrev ():

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

Skupienie się na początkach, jeśli masz pewność, że łańcuchy nie są puste, dodanie testu dla pierwszego znaku, przed porównaniem, strlen itp., Nieco przyspiesza:

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

Jest w jakiś sposób (20% -30%) szybszy. Dodanie kolejnego testu char, np. $ Haystack {1} === $ igła {1}, wydaje się nie przyspieszać, może nawet spowolnić.

===wydaje się szybszy niż == Operator warunkowy (a)?b:cwydaje się szybszy niżif(a) b; else c;

Dla tych, którzy pytają „dlaczego nie użyć strpos?” nazywając inne rozwiązania „niepotrzebną pracą”

strpos jest szybki, ale nie jest odpowiednim narzędziem do tego zadania.

Aby zrozumieć, oto mała symulacja jako przykład:

Search a12345678c inside bcdefga12345678xbbbbb.....bbbbba12345678c

Co komputer robi „w środku”?

    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

Zakładając, że strlen nie iteruje całego łańcucha (ale nawet w takim przypadku), nie jest to wcale wygodne.

Mam nadzieję, że poniższa odpowiedź może być skuteczna, a także prosta:

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

Zazwyczaj ostatnio kończę na bibliotece takiej jak podkreślenie-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   

Biblioteka jest pełna innych przydatnych funkcji.

Odpowiedź przez MPpl jest niezwykle dokładny, ale, niestety, pod warunkiem odniesienia ma bardzo istotny i niekorzystny nadzoru.

Ponieważ każdy bajt w igłach i stogach siana jest całkowicie losowy, prawdopodobieństwo, że para igły i stogu siana będzie się różnić na pierwszym bajcie wynosi 99,609375%, co oznacza, że ​​średnio około 99609 ze 100000 par będzie się różnić na pierwszym bajcie . Innymi słowy, test porównawczy jest mocno ukierunkowany na startswithimplementacje, które wyraźnie sprawdzają pierwszy bajt, jakstrncmp_startswith2 .

Jeśli zamiast tego implementowana jest pętla generująca testy, to:

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 />";

wyniki testu porównawczego przedstawiają nieco inną historię:

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

Oczywiście ten test porównawczy może nadal nie być całkowicie bezstronny, ale testuje wydajność algorytmów, gdy podaje się częściowo pasujące igły.

w skrócie:

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

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

Tylko zalecenie:

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

Ta dodatkowa linia, porównująca pierwszy znak ciągów, może sprawić, że fałszywy przypadek natychmiast powróci , dzięki czemu wiele twoich porównań będzie znacznie szybszych (7 razy szybszych, gdy mierzę). W prawdziwym przypadku za tę pojedynczą linię praktycznie nie płacisz żadnej ceny, więc myślę, że warto ją uwzględnić. (Ponadto w praktyce, gdy testujesz wiele ciągów dla określonej początkowej porcji, większość porównań zakończy się niepowodzeniem, ponieważ w typowym przypadku szukasz czegoś.)

substrFunkcja może powrócić falsew wielu przypadkach szczególnych, więc tutaj jest moja wersja, która zajmuje się tymi zagadnieniami:

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
}

Testy ( trueznaczy dobre):

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

substr_compareWarto również sprawdzić tę funkcję. http://www.php.net/manual/en/function.substr-compare.php

To może działać

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

Źródło: https://stackoverflow.com/a/4419658

Zrobiłbym to w ten sposób

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

W oparciu o odpowiedź Jamesa Blacka, oto jego koniec W wersji:

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

}

Uwaga: zamieniłem część if-else dla funkcji Jamesa Blacka startWith, ponieważ strncasecmp jest w rzeczywistości rozróżniającą wielkość liter wersją strncmp.

Dlaczego nie następujące?

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

Wynik:

Znaleziono wartość na początku valuehaystack!

Pamiętaj, strposzwróci wartość false, jeśli igła nie została znaleziona w stogu siana, i zwróci 0, jeśli i tylko wtedy, gdy igła została znaleziona przy indeksie 0 (AKA początek).

A oto koniec:

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

W tym scenariuszu nie ma potrzeby uruchamiania funkcji StartWith () as

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

zwróci dokładnie prawda lub fałsz.

Wydaje się dziwne, że jest to takie proste, gdy szaleją tu wszystkie dzikie funkcje.

Wiele wcześniejszych odpowiedzi będzie działać równie dobrze. Jest to jednak możliwie jak najkrótsze i możesz zrobić to, co chcesz. Po prostu oświadczasz, że chciałbyś, aby „zwrócił prawdę”. Dołączyłem więc rozwiązania zwracające wartość logiczną prawda / fałsz i tekstowe prawda / fałsz.

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

Możesz także użyć wyrażeń regularnych:

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

Pętla bez kopii i bez internowania:

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

Oto wydajne rozwiązanie dla PHP 4. Możesz uzyskać szybsze wyniki, jeśli na PHP 5, używając substr_comparezamiast 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;
}

Możesz użyć do tego funkcji fnmatch .

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