str_starts_with and str_ends_with functions in PHP

Question 1

How can I write two functions that would take a string and return if it starts with the specified character/string or ends with it?

For example:

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

Question 2

See Laravel's Str class startsWith() and endsWith() for well-tested methods. Edge cases had been encountered, so the widespread use of this code is an advantage.

Question 3

You might find s($str)->startsWith('|') and s($str)->endsWith('}') helpful, as found in this standalone library.

Question 4

Warning: most answers here are unreliable in multi-byte encodings such as UTF-8.

Question 5

Following up to my above comment, you may make sure to use the latest version (as of today, 5.4). Notably, startsWith() has been optimized for large haystack strings.

Question 6

PHP 8.0 introduces new methods for this job str_starts_with and str_end_with: stackoverflow.com/a/64160081/7082164

Question 7

PHP 8.0 and higher

Since PHP 8.0 you can use:

str_starts_with and
str_ends_with

Example

var_dump(str_starts_with('|apples}', '|'));
var_dump(str_ends_with('|apples}', '}'));

PHP before 8.0

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

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

Question 8

I'd say endsWith('foo', '') == false is the correct behavior. Because foo doesn't end with nothing. 'Foo' ends with 'o', 'oo' and 'Foo'.

Question 9

EndsWith can be written a lot shorter: return substr($haystack, -strlen($needle))===$needle;

Question 10

@RokKralj But only if $needle is not empty.

Question 11

You can avoid the if altogether by passing $length as the third parameter to substr: return (substr($haystack, -$length, $length);. This handles the case of $length == 0 by returning an empty string and not the whole $haystack.

Question 12

@MrHus I would recommend using multi-byte safe functions, e.g. mb_strlen and mb_substr

Question 13

PHP < 8

You can use substr_compare function to check start-with and ends-with:

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

^{This should be one of the fastest solutions on PHP 7 (benchmark script). Tested against 8KB haystacks, various length needles and full, partial and no match cases. strncmp is a touch faster for starts-with but it cannot check ends-with.}

Question 14

Please note that @DavidWallace and @FrancescoMM comments apply to an older version of this answer. The current answer uses strrpos which (should) fail immediately if needle does not match the beginning of haystack.

Question 15

I don't get it. Based on php.net/manual/en/function.strrpos.php: "If the value is negative, search will instead start from that many characters from the end of the string, searching backwards." This seems to indicate that we're starting at character 0 (due to -strlength($haystack)) and searching backward from there? Doesn't that mean you're not searching anything? I also don't understand the !== false parts of this. I'm guessing this is relying on a quirk of PHP where some values are "truthy" and others "falsy" but how does that work in this case?

Question 16

@Welbog: for example haystack = xxxyyy needle = yyy and using strrpos the search starts from the first x. Now we do not have a successful match here (found x instead of y) and we cannot go backward anymore (we're at start of string) the search fails immediately. About using !== false -- strrpos in the above example will return 0 or false and not other value. Likewise, strpos in the above example can return $temp (the expected position) or false. I went with !== false for consistency but you could use === 0 and === $temp in the functions respectively.

Question 17

So much unnecessary work on this. Why not use strpos === 0 for the startsWith. Down voted for drastically over complicating suboptimal coding response.

Question 18

@spoo it has already been established that strpos === 0 is a terrible solution if haystack is large and needle does not exist.

Question 19

Updated 23-Aug-2016

Functions

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

Results (PHP 7.0.9)

(Sorted fastest to slowest)

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

Results (PHP 5.3.29)

(Sorted fastest to slowest)

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

Question 20

If the strings are not empty, as in your tests, this is actually somehow (20-30%) faster:

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

I added a reply below.

Question 21

@Jronny Because 110 is less than 133...??

Question 22

Darn, I don't know what went to my head that time. Prolly the lack of sleep.

Question 23

@mpen, I noticed not the elephant at all :(

Question 24

$haystack[0] will throw a notice error if you don't test it with isset. The same for needles. But if you add tests, it will slow down its performance

Question 25

All answers so far seem to do loads of unnecessary work, strlen calculations, string allocations (substr), etc. The 'strpos' and 'stripos' functions return the index of the first occurrence of $needle in $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;
}

Question 26

endsWith() function has an error. Its first line should be (without the -1): $expectedPosition = strlen($haystack) - strlen($needle);

Question 27

The strlen() thing is not unnecessary. In case the string doesn't start with the given needle then ur code will unnecessarily scan the whole haystack.

Question 28

@Mark yea, checking just the beginning is a LOT faster, especially if you're doing something like checking MIME types (or any other place where the string is bound to be large)

Question 29

@mark I did some benchmarks with 1000 char haystack and 10 or 800 char needle and strpos was 30% faster. Do your benchmarks before stating that something is faster or not...

Question 30

You should strongly consider quoting the needle like strpos($haystack, "$needle", 0) if there's any chance it's not already a string (e.g., if it's coming from json_decode()). Otherwise, the [odd] default behavior of strpos() may cause unexpected results: "If needle is not a string, it is converted to an integer and applied as the ordinal value of a character."

Question 31

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

Credit To:

Check if a string ends with another string

Check if a string begins with another string

Question 32

strtolower is not the best way to make case insensitive functions. In some locales casing is more complex than just upper and lower.

Question 33

I see complaining and no solution... If you're gonna say it's bad, then you should give an example of how it should be as well.

Question 34

@WebDevHobo: that's why I added an answer myself a day before your comment. For your code strcasecmp was indeed the right thing to do.

Question 35

PHP 8 update

PHP 8 includes new str_starts_with and str_ends_with functions that finally provide a performant and convenient solution to this problem:

$str = "beginningMiddleEnd";
if (str_starts_with($str, "beg")) echo "printed\n";
if (str_starts_with($str, "Beg")) echo "not printed\n";
if (str_ends_with($str, "End")) echo "printed\n";
if (str_ends_with($str, "end")) echo "not printed\n";

The RFC for this feature provides more information, and also a discussion of the merits and problems of obvious (and not-so-obvious) userland implementations.

Question 36

This question already has many answers, but in some cases you can settle for something simpler than all of them. If the string you're looking for is known (hardcoded), you can use regular expressions without any quoting etc.

Check if a string starts with 'ABC':

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

ends with 'ABC':

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

In my simple case, I wanted to check if a string ends with slash:

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

The advantage: since it's very short and simple, you don't have to define a function (such as endsWith()) as shown above.

But again -- this is not a solution for every case, just this very specific one.

Question 37

you don't need to hard code the string. the regex can be dynamic.

Question 38

@self true, but if the string is not hardcoded, you have to escape it. Currently there are 2 answers on this question that do it. This is easy, but it complicates the code just a bit. So my point was that for very simple cases, where hardcoding is possible, you can keep it simple.

Question 39

The regex functions above, but with the other tweaks also suggested above:

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

Question 40

in php for string operations the ordering of parameters is $haystack, $needle. these functions are backwards and act like array functions where the ordering is actually $needle, $haystack.

Question 41

Fastest endsWith() solution:

# 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 Results:

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

Question 42

+1 for taking time to compare different solutions and actually benchmark them! you should also mention what version of PHP you used, as optimisations are done as the language evolves! I've seen dramatic improvements on string comparison functions from one PHP version to another :)

Question 43

echoing @ChristopheDeliens and his request to provide the PHP version. I ran your test on 7.3.2 and got similar results FWIW.

Question 44

If speed is important for you, try this.(I believe it is the fastest method)

Works only for strings and if $haystack is only 1 character

function startsWithChar($needle, $haystack)
{
 return ($needle === $haystack[0]);
}
function endsWithChar($needle, $haystack)
{
 return ($needle === $haystack[strlen($haystack) - 1]);
}
$str='|apples}';
echo startsWithChar('|',$str); //Returns true
echo endsWithChar('}',$str); //Returns true
echo startsWithChar('=',$str); //Returns false
echo endsWithChar('#',$str); //Returns false

Question 45

this is probably the most efficient answer because not using any function as extra, just usual string...

Question 46

It should likely check if string has at least one character and has the two parameter swapped

Question 47

Creative. Needles which contain haystacks. BTW there is some ugly waning with: endsWithChar('','x'), but the result is correct

Question 48

I like your answer, but it's quite funny,... the needle and haystack are the other way around :) ... i.e. you would search for a Needle in a Haystack, therefore, it should be: return ($needle === $haystack[0]); , but nice answer, thanks!

Question 49

@HeiderSati: Great observation! That is what @Tino was talking about Creative. Needles which contain haystacks.... I didn't pay enough attention. Thanks! I fixed it. :)

Question 50

Here are two functions that don't introduce a temporary string, which could be useful when needles are substantially big:

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

Question 51

+1 Works since PHP5.1 and IMHO best answer. But endsWidth should do return $needle==='' || substr_compare(... so it works as expected for -strlen($needle)===0 which, without the fix, makes endsWith('a','') return false

Question 52

@Tino Thanks ... I feel that's a bug in substr_compare() actually, so I've added a PR to fix that :)

Question 53

The call endsWith('', 'foo') triggers a Warning: "substr_compare(): The start position cannot exceed initial string length". Maybe that's another bug in substr_compare(), but to avoid it, you need a pre-check like ...|| (strlen($needle) <= strlen($haystack) && substr_compare(...) === 0);

Question 54

@gx_ No need to slowdown with more code. Just use return $needle === '' || @substr_compare(.. to suppress this warning.

Question 55

I realize this has been finished, but you may want to look at strncmp as it allows you to put the length of the string to compare against, so:

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

Question 56

how would you do endswith with this?

Question 57

@Mark - you can look at the accepted answer, but I prefer to use strncmp mainly because I think it is safer.

Question 58

I mean with strncmp specifically. You can't specify an offset. That would mean your endsWith function would have to use a different method entirely.

Question 59

@Mark - For endsWith I would just use strrpos (php.net/manual/en/function.strrpos.php), but, generally, anytime you go to use strcmp strncmp is probably a safer option.

Question 60

Here's a multi-byte safe version of the accepted answer, it works fine for UTF-8 strings:

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

Question 61

im pretty sure this is just a waste of CPU. all you need to check, for StarstWith and EndsWith, is just checking that the bytes match, and that's exactly what the accepted answer is doing. this 1 wastes time calculating the number of utf8 characters of the needle, and where the position of the n'th utf8 character of the haystack is.. i think, without being 100% certain, this is just a waste of cpu. can you come up with an actual test case where the accepted answer fails, and this doesn't?

Question 62

@hanshenrik - it could happen btw, in the very rare case when you look for a string that contains the same bytes as an UTF8 but with half of the last character missing. Like, you have unicode C5 91 (letter "ő") and you look for C5 (letter "Å") it shouldn't give you a match. On the other hand, sure, why would you search an utf haystack for a non-utf needle... But for bulletproof checks, this must be considered a possibility.

Question 63

In startsWith it should be $length = mb_strlen($needle, 'UTF-8');

Question 64

@ThomasKekeisen Thanks, fixed it.

MrHus 33.5k6 gold badges33 silver badges31 bronze badges · Accepted Answer · 2009-05-07 12:24:25Z

1872

Answer recommended by PHP Collective

PHP 8.0 and higher

Since PHP 8.0 you can use:

str_starts_with and
str_ends_with

Example

var_dump(str_starts_with('|apples}', '|'));
var_dump(str_ends_with('|apples}', '}'));

PHP before 8.0

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

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

Share

Improve this answer

edited Dec 23, 2023 at 12:16

Salman Arshad's user avatar

Salman Arshad

274k85 gold badges450 silver badges540 bronze badges

answered May 7, 2009 at 12:24

MrHus's user avatar

MrHus

33.5k6 gold badges33 silver badges31 bronze badges

Sign up to request clarification or add additional context in comments.

33 Comments

MrHus

MrHus Over a year ago

I'd say endsWith('foo', '') == false is the correct behavior. Because foo doesn't end with nothing. 'Foo' ends with 'o', 'oo' and 'Foo'.

2012年04月13日T13:34:58.283Z+00:00

Rok Kralj

Rok Kralj Over a year ago

EndsWith can be written a lot shorter: return substr($haystack, -strlen($needle))===$needle;

2012年06月11日T09:57:45.46Z+00:00

Ja͢ck

Ja͢ck Over a year ago

@RokKralj But only if $needle is not empty.

2014年02月21日T03:01:01.07Z+00:00

mxxk

mxxk Over a year ago

You can avoid the if altogether by passing $length as the third parameter to substr: return (substr($haystack, -$length, $length);. This handles the case of $length == 0 by returning an empty string and not the whole $haystack.

2015年01月23日T01:21:18.54Z+00:00

19Gerhard85

19Gerhard85 Over a year ago

@MrHus I would recommend using multi-byte safe functions, e.g. mb_strlen and mb_substr

2016年04月25日T08:49:28.147Z+00:00

|

CollectivesTM on Stack Overflow

37 Answers 37

PHP 8.0 and higher

Example

PHP before 8.0

33 Comments

PHP < 8

6 Comments

Functions

Tests

Results (PHP 7.0.9)

Results (PHP 5.3.29)

22 Comments

14 Comments

3 Comments

PHP 8 update

Comments

2 Comments

1 Comment

Fastest endsWith() solution:

Benchmark:

Benchmark Results:

2 Comments

5 Comments

4 Comments

4 Comments

5 Comments

1 Comment

4 Comments

2 Comments

Comments

Comments

1 Comment

Comments

Note:

So here's a tiny improvement to startsWith:

As for strings vs integers

5 Comments

Comments

Comments

4 Comments

1 Comment

2 Comments

3 Comments

1 Comment

Comments

1 Comment

Linked

Related