Możliwe jest użycie strrpos oraz strpos aby sprawdzić odpowiednio początek-z i koniec-z.

Zauważ, że użycie {[2] } do sprawdzania zaczyna się od I strpos do sprawdzania kończy się od zwróci się tak szybko, jak to możliwe, zamiast sprawdzać cały łańcuch aż do końca. Ponadto To rozwiązanie nie tworzy tymczasowego ciągu znaków. Rozważ wyjaśnienie przyczyny przed odrzuceniem głosowania. Tylko dlatego, że f-wit w DWTF nie rozumie jak działa ta funkcja lub myśli, że jest tylko jedna rozwiązanie nie oznacza, że ta odpowiedź jest błędna.

function startsWith($haystack, $needle) {
    // search backwards starting from haystack length characters from the end
    return $needle === ''
      || strrpos($haystack, $needle, -strlen($haystack)) !== false;
}

function endsWith($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;
}

Testy i wyniki (porównaj z tym):

startsWith('abcdef', 'ab') -> true
startsWith('abcdef', 'cd') -> false
startsWith('abcdef', 'ef') -> false
startsWith('abcdef', '') -> true
startsWith('', 'abcdef') -> false

endsWith('abcdef', 'ab') -> false
endsWith('abcdef', 'cd') -> false
endsWith('abcdef', 'ef') -> true
endsWith('abcdef', '') -> true
endsWith('', 'abcdef') -> false

Uwaga: funkcje strncmp i substr_compare przewyższą tę funkcję.

Zaktualizowano 23-Aug-2016

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)

(sortowane najszybciej do najwolniej)

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)

(sortowane najszybciej do najwolniej)

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

Startswith_benchmark.php

Wszystkie odpowiedzi do tej pory wydają się wykonywać mnóstwo niepotrzebnej pracy, strlen calculations, string allocations (substr), itd. Funkcje 'strpos' i 'stripos' zwracają indeks pierwszego wystąpienia $needle w $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 Na :

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

Sprawdź, czy łańcuch zaczyna się od innego łańcucha

Funkcje regex powyżej, ale z innymi poprawkami 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);
 }

Jeśli prędkość jest dla ciebie ważna, spróbuj tego.(Uważam, że jest to najszybsza Metoda)

Działa tylko dla łańcuchów i jeśli $haystack jest tylko 1 znakiem

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

Zdaję sobie sprawę, że to już koniec, ale może warto spojrzeć na strncmp , ponieważ pozwala na porównanie długości łańcucha, 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;
}    

Oto dwie funkcje, które nie wprowadzają tymczasowego ciągu, co może 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;
}

To pytanie ma już wiele odpowiedzi, ale w niektórych przypadkach można zadowolić się czymś prostszym niż wszystkie z nich. Jeśli szukany ciąg znaków jest znany( zakodowany na twardo), możesz używać wyrażeń regularnych bez cytowania itp.

Sprawdź, czy łańcuch 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);   // slash has to be quoted

Zaleta: ponieważ jest bardzo krótki i prosty, nie musisz definiować funkcja (taka jak endsWith()), Jak pokazano powyżej.

Możesz użyć strpos Oraz strrpos

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

Krótkie i łatwe do zrozumienia jednowiersze bez wyrażeń regularnych.

Funkcja StartsWith () jest prosta.

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

EndsWith () używa nieco wymyślnego i powolnego strrev ():

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

Skupiając się na startswith, jeśli jesteś pewien, że ciągi nie są puste, Dodaj test na pierwszym znaku, przed porównaniem, strlen itp., przyspiesza trochę:

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

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

Dla tych, którzy pytają " dlaczego nie używać strpos?"calling inne rozwiązania "niepotrzebna praca"

Strpos jest szybki, ale nie jest odpowiednim narzędziem do tej pracy.

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

Search a12345678c inside bcdefga12345678xbbbbb.....bbbbba12345678c

Co robi komputer "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 ciągu (ale nawet w tym przypadku), nie jest to wcale wygodne.

W dzisiejszych czasach Zwykle kończę z biblioteką typu 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   

Biblioteka jest pełna innych przydatnych funkcji.

Odpowiedź przez mpen jest niezwykle dokładna, ale, niestety, podany benchmark ma bardzo ważne i szkodliwe niedopatrzenie.

Ponieważ każdy bajt w igłach i stogach siana jest całkowicie losowy, prawdopodobieństwo, że para igła-stóg siana będzie się różnić w pierwszym bajcie wynosi 99,609375%, co oznacza, że średnio około 99609 z 100000 par będzie się różnić w pierwszym bajcie. Innymi słowy, benchmark jest mocno tendencyjny w kierunku startswith implementacje, które jawnie sprawdzają pierwszy bajt, tak jak robi to strncmp_startswith2.

Jeśli pętla generująca test jest zaimplementowana w następujący sposób:

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 benchmarka opowiadają 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 benchmark może nadal nie być całkowicie bezstronny, ale testuje wydajność algorytmów, gdy podano częściowo dopasowane igły.

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

function startsWith($haystack, $needle)
{
    $length = mb_substr($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);
}

Mam nadzieję, że poniższa odpowiedź może być skuteczna i jednocześnie 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';

Funkcja substr może zwracać false w wielu szczególnych przypadkach, więc oto moja wersja, która dotyczy tych problemów:

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 (true oznacza 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'));

Również funkcja substr_compare również warto szukać. http://www.php.net/manual/en/function.substr-compare.php

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

Najszybsze rozwiązanie endsWith ():

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

Wyniki Porównawcze:

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

To może zadziałać

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

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

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

Wyjście:

Znaleziono wartość na początku valuehaystack!

Pamiętaj, że strpos zwróci 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 w indeksie 0 (aka początek).

A tu 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 stosowania funkcji startsWith () jako

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

Zwróci true lub false dokładnie.

Wydaje się dziwne, że to takie proste, a wszystkie dzikie funkcje tutaj szaleją.

I would do it like this

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

Tylko zalecenie:

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

Ta dodatkowa linia, porównując pierwszy znak ciągów, może sprawić, że false case return natychmiast , dlatego dokonując wielu porównań dużo szybciej (7x szybciej, gdy mierzyłem). W prawdziwym przypadku nie płacisz praktycznie żadnej ceny w wydajności dla tej pojedynczej linii, więc myślę, że warto w tym. (Również, w praktyce, gdy testujesz wiele ciągów dla określonego początkowego fragmentu, większość porównań zawiedzie, Ponieważ w typowym przypadku szukasz czegoś.)

Na podstawie odpowiedzi Jamesa Blacka, oto jej zakończenie 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 na funkcję StartsWith Jamesa Blacka, ponieważ strncasecmp jest w rzeczywistości niewrażliwą na wielkość liter wersją strncmp.

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

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

Wiele z poprzednich odpowiedzi będzie działać tak samo dobrze. Jednak jest to prawdopodobnie tak krótkie, jak możesz to zrobić i zrobić to, czego pragniesz. Po prostu oświadczasz, że chcesz, aby to "powróciło do prawdy". Więc zawarłem rozwiązania, które zwracają logiczne true/false I tekstowe true / false.

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

Oto skuteczne rozwiązanie dla PHP 4. Możesz uzyskać szybsze wyniki, jeśli w PHP 5 użyjesz substr_compare zamiast 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;
}

$ends_with = strrchr($text, '.'); // Ends with dot
$start_with = (0 === strpos($text, '.')); // Starts with dot

Nie wiem, dlaczego jest to takie trudne dla ludzi. Substr robi świetną robotę i jest wydajny, ponieważ nie musisz przeszukiwać całego ciągu, jeśli nie pasuje.

Dodatkowo, ponieważ nie sprawdzam wartości całkowitych, ale porównuję ciągi znaków, nie muszę koniecznie martwić się o strict = = = case. Jednak = = = jest dobrym nawykiem, aby dostać się do.

function startsWith($haystack,$needle) {
  substring($haystack,0,strlen($needle)) == $needle) { return true; }
   return false;
}

function endsWith($haystack,$needle) {
  if(substring($haystack,-strlen($needle)) == $needle) { return true; }
   return false;
}

Lub nawet lepiej zoptymalizowany.

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

function endsWith($haystack,$needle) {
  return substring($haystack,-strlen($needle)) == $needle);
}