PHP: strrpos - Manual

Description

int strrpos ( string haystack, string needle [, int offset] )

Returns the numeric position of the last occurrence of needle in the haystack string. Note that the needle in this case can only be a single character in PHP 4. If a string is passed as the needle, then only the first character of that string will be used.

If needle is not found, returns FALSE.

It is easy to mistake the return values for "character found at position 0" and "character not found". Here's how to detect the difference:


<?php



// in PHP 4.0b3 and newer:

$pos = strrpos($mystring, "b");

if ($pos === false) { // note: three equal signs

    // not found...

}



// in versions older than 4.0b3:

$pos = strrpos($mystring, "b");

if (is_bool($pos) && !$pos) {

    // not found...

}

?>

If needle is not a string, it is converted to an integer and applied as the ordinal value of a character.

Notatka: As of PHP 5.0.0 offset may be specified to begin searching an arbitrary number of characters into the string. Negative values will stop searching at an arbitrary point prior to the end of the string.

Notatka: The needle may be a string of more than one character as of PHP 5.0.0.

User Contributed Notes


As noted in some examples below, strrpos does not act the same on every platform!



On Linux, it returns the position of the end of the target

On Windows, it returns the position of the start of the target



strrpos ("c:/somecity/html/t.php")



returns 11 on Windows

returns 16 on Linux



Brian


The "find-last-occurrence-of-a-string" functions suggested here do not allow for a starting offset, so here's one, tried and tested, that does:



function my_strrpos($haystack, $needle, $offset=0) {

    // same as strrpos, except $needle can be a string

    $strrpos = false;

    if (is_string($haystack) && is_string($needle) && is_numeric($offset)) {

        $strlen = strlen($haystack);

        $strpos = strpos(strrev(substr($haystack, $offset)), strrev($needle));

        if (is_numeric($strpos)) {

            $strrpos = $strlen - $strpos - strlen($needle);

        }

    }

    return $strrpos;

}


RE: hao2lian



There are a lot of alternative - and unfortunately buggy - implementations of strrpos() (or last_index_of as it was called) on this page. This one is a slight modifiaction of the one below, but it should world like a *real* strrpos(), because it returns false if there is no needle in the haystack.



<?php



function my_strrpos($haystack, $needle) {

   $index = strpos(strrev($haystack), strrev($needle));

   if($index === false) {

        return false;

   }

   $index = strlen($haystack) - strlen($needle) - $index;

   return $index;

}



?>


If you are a VBScript programmer ("ex-" of course), you will find that 'strrpos' doesn't work like the VBScript 'instrRev' function.



Here is the equivalent function:



VBScript:



k=instrrev(s,">",j);



PHP Equivalent of the above VBScript:



$k=strrpos(substr($s,0,$j),'>');



Comments:



You might think (I did!) that the following PHP function call would be the equivant of the above VBScript call:



$kk=strrpos($s,'>',$j);



NOPE!  In the above PHP call, $j defines the position in the string that should be considered the BEGINNING of the string, whereas in the VBScript call, j is to be considered the END of the string, as far as this search is concerned.  Anyway, the above 'strrpos' with the 'substr' will work.

(Probably faster to write a for loop!)


Yet another correction on the last_index_of function algorithm:



function last_index_of($haystack, $needle) {

    $index = strpos(strrev($haystack), strrev($needle));

    $index = strlen($haystack) - strlen($needle) - $index;

    return $index;

}



"strlen(index)" in the most recent one should be "strlen($needle)".


I was immediatley pissed when i found the behaviour of strrpos ( shouldnt it be called charrpos ?) the way it is, so i made my own implement to search for strings.



<?

function proper_strrpos($haystack,$needle){

        while($ret = strrpos($haystack,$needle))

        {       

                if(strncmp(substr($haystack,$ret,strlen($needle)),

                                $needle,strlen($needle)) == 0 )

                        return $ret;

                $haystack = substr($haystack,0,$ret -1 );

        }

        return $ret;

}

?>


If you wish to look for the last occurrence of a STRING in a string (instead of a single character) and don't have mb_strrpos working, try this:



    function lastIndexOf($haystack, $needle) {

        $index        = strpos(strrev($haystack), strrev($needle));

        $index        = strlen($haystack) - strlen(index) - $index;

        return $index;

    }


Function like the 5.0 version of strrpos for 4.x.

This will return the *last* occurence of a string within a string.



    function strepos($haystack, $needle, $offset=0) {        

        $pos_rule = ($offset<0)?strlen($haystack)+($offset-1):$offset;

        $last_pos = false; $first_run = true;

        do {

            $pos=strpos($haystack, $needle, (intval($last_pos)+(($first_run)?0:strlen($needle))));

            if ($pos!==false && (($offset<0 && $pos <= $pos_rule)||$offset >= 0)) {

                $last_pos = $pos;

            } else { break; }

            $first_run = false;

        } while ($pos !== false);

        if ($offset>0 && $last_pos<$pos_rule) { $last_pos = false; }

        return $last_pos;

    }



If my math is off, please feel free to correct.

  - A positive offset will be the minimum character index position of the first character allowed.

  - A negative offset will be subtracted from the total length and the position directly before will be the maximum index of the first character being searched.



returns the character index ( 0+ ) of the last occurence of the needle. 



* boolean FALSE will return no matches within the haystack, or outside boundries specified by the offset.


this is my function for finding a filename in a URL:





<?php


    function getfname($url){


        $pos = strrpos($url, "/");


        if ($pos === false) {


            // not found / no filename in url...


            return false;


        } else {


            // Get the string length


            $len = strlen($url);


            if ($len < $pos){


                        print "$len / $pos";


                // the last slash we found belongs to http:// or it is the trailing slash of a URL


                return false;


            } else {


                $filename = substr($url, $pos+1, $len-$pos-1);


            }


        }


        return $filename;


    }


?>


What the heck, I thought I'd throw another function in the mix.  It's not pretty but the following function counts backwards from your starting point and tells you the last occurrance of a mixed char string:





<?php


function strrposmixed ($haystack, $needle, $start=0) {


   // init start as the end of the str if not set


   if($start == 0) {


       $start = strlen($haystack);


   }


   


   // searches backward from $start


   $currentStrPos=$start;


   $lastFoundPos=false;


   


   while($currentStrPos != 0) {


       if(!(strpos($haystack,$needle,$currentStrPos) === false)) {


           $lastFoundPos=strpos($haystack,$needle,$currentStrPos);


           break;


       }


       $currentStrPos--;


   }


   


   if($lastFoundPos === false) {


       return false;


   } else {


       return $lastFoundPos;


   }


}


?>


This function does what strrpos would if it handled multi-character strings:





<?php


function getLastStr($hay, $need){


  $getLastStr = 0;


  $pos = strpos($hay, $need);


  if (is_int ($pos)){ //this is to decide whether it is "false" or "0"


    while($pos) {


      $getLastStr = $getLastStr + $pos + strlen($need);


      $hay = substr ($hay , $pos + strlen($need));


      $pos = strpos($hay, $need);


    }


    return $getLastStr - strlen($need);


  } else {


    return -1; //if $need wasn