Edit Report a Bug

    strrpos

    (PHP 4, PHP 5, PHP 7, PHP 8)

    strrpos — Findet die Position des letzten Vorkommens eines Teilstrings innerhalb einer Zeichenkette

    Beschreibung

    strrpos(string $haystack, string $needle, int $offset = 0): int|false

    Gibt die numerische Position des letzten Vorkommens von needle innerhalb der Zeichenkette haystack zurück.

    Parameter-Liste

    haystack

    Die Zeichenkette in der gesucht werden soll.

    needle

    Die Zeichenkette, nach der gesucht werden soll.

    Wenn der Parameter needle keine Zeichenkette ist, wird er vor PHP 8.0.0 in eine Ganzzahl umgewandelt und als ordinaler Wert eines Zeichens betrachtet. Dieses Verhalten gilt seit PHP 7.3.0 als veraltet und es wird dringend empfohlen, sich nicht darauf zu verlassen. Ist das Verhalten gewünscht, so sollte needle explizit in eine Zeichenkette umgewandelt werden oder explizit die Funktion chr() aufgerufen werden.

    offset

    Wenn null (0) oder positiv, wird die Suche von links nach rechts durchgeführt, wobei die ersten offset Bytes von haystack übersprungen werden.

    Wenn negativ, beginnt die Suche offset Bytes von rechts statt vom Anfang von haystack. Die Suche wird von rechts nach links durchgeführt, wobei nach dem ersten Vorkommen von needle ab dem ausgewählten Byte gesucht wird.

    Hinweis:

    Dies bedeutet, dass das letzte Vorkommen von needle an oder vor den letzten offset Bytes gesucht wird.

    Rückgabewerte

    Gibt die Position des Vorkommens des gesuchten Teilstrings relativ zum Anfang der Zeichenkette haystack (unabhängig von Suchrichtung oder Offset) zurück.

    Hinweis: Positionen in Zeichenketten werden ab 0 gezählt, und nicht ab 1.

    Gibt false zurück, falls der gesuchte Teilstring nicht gefunden wurde.

    Warnung

    Diese Funktion kann sowohl das boolsche false zurückliefern, als auch einen nicht-boolschen Wert, welcher zu false ausgewertet wird. Weitere Informationen entnehmen Sie bitte dem Abschnitt über die boolschen Typen. Benutzen Sie deshalb den === Operator, um den Rückgabewert dieser Funktion zu überprüfen.

    Changelog

    Version Beschreibung
    8.0.0 needle akzeptiert nun eine leere Zeichenkette.
    8.0.0 Die Übergabe eines Integer als needle wird nicht mehr unterstützt.
    7.3.0 Die Übergabe eines Integer als needle wird missbilligt.

    Beispiele

    Beispiel #1 Prüfen ob needle in haystack vorkommt

    Es liegt nahe, einen Fehler bei der Auswertung der Rückgabewerte von "Zeichen an Position 0 gefunden" und "Zeichen nicht gefunden" zu begehen. Am einfachsten finden Sie den Unterschied wie folgt heraus:

    <?php

    $pos     = strrpos($meinstring, "b");
    if (    $pos === false) { // Beachten sie die drei Gleichheitszeichen
    // nicht gefunden ...
    }

    ?>

    Beispiel #2 Mit Offsets suchen

    <?php
    $foo     = "0123456789a123456789b123456789c";

    // Sucht '0' ab dem nullten Byte (vom Anfang an)
    var_dump(strrpos($foo, '0', 0));

    // Sucht '0' ab dem ersten Byte (nach Byte "0")
    var_dump(strrpos($foo, '0', 1));

    // Sucht '7' ab dem 21ten Byte (nach Byte 20)
    var_dump(strrpos($foo, '7', 20));

    // Sucht '7' ab dem 29ten Byte (nach Byte 28)
    var_dump(strrpos($foo, '7', 28));

    // Sucht '7' von rechts nach links ab dem fünften Byte vom Ende
    var_dump(strrpos($foo, '7', -5));

    // Sucht 'c' von rechts nach links ab dem zweiten Byte vom Ende
    var_dump(strrpos($foo, 'c', -2));

    // Sucht '9c' von rechts nach links ab dem zweiten Byte vom Ende
    var_dump(strrpos($foo, '9c', -2));
    ?>

    Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

    int(0)
bool(false)
int(27)
bool(false)
int(17)
bool(false)
int(29)

    Siehe auch

    • strpos() - Sucht die Position des ersten Vorkommens des Suchstrings in einem String
    • stripos() - Findet das erste Vorkommen eines Teilstrings in einem String, unabhängig von Groß- und Kleinschreibung
    • strripos() - Findet das letzte Vorkommen der gesuchten Zeichenkette in einem String, unabhängig von Groß- und Kleinschreibung
    • strrchr() - Sucht das letzte Vorkommen eines Zeichens in einem String
    • substr() - Liefert einen Teil eines Strings

    add a note add a note

    User Contributed Notes 35 notes

    up
    77
    brian at enchanter dot net
    17 years ago
    The documentation for 'offset' is misleading.

    It says, "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."

    This is confusing if you think of strrpos as starting at the end of the string and working backwards.

    A better way to think of offset is:

    - If offset is positive, then strrpos only operates on the part of the string from offset to the end. This will usually have the same results as not specifying an offset, unless the only occurences of needle are before offset (in which case specifying the offset won't find the needle).

    - If offset is negative, then strrpos only operates on that many characters at the end of the string. If the needle is farther away from the end of the string, it won't be found.

    If, for example, you want to find the last space in a string before the 50th character, you'll need to do something like this:

    strrpos($text, " ", -(strlen($text) - 50));

    If instead you used strrpos($text, " ", 50), then you would find the last space between the 50th character and the end of the string, which may not have been what you were intending.
    up
    4
    david dot mann at djmann dot co dot uk
    6 years ago
    Ten years on, Brian's note is still a good overview of how offsets work, but a shorter and simpler summary is:

        strrpos($x, $y, 50);  // 1: this tells strrpos() when to STOP, counting from the START of $x
        strrpos($x, $y, -50); // 2: this tells strrpos() when to START, counting from the END of $x

    Or to put it another way, a positive number lets you search the rightmost section of the string, while a negative number lets you search the leftmost section of the string.

    Both these variations are useful, but picking the wrong one can cause some highly confusing results!
    up
    3
    dave at pixelmetrics dot com
    5 years ago
    The description of offset is wrong. Here’s how it works, with supporting examples.

    Offset effects both the starting point and stopping point of the search. The direction is always right to left. (The description wrongly says PHP searches left to right when offset is positive.)

    Here’s how it works:
    When offset is positive, PHP searches right to left from the end of haystack to offset. This ignores the left side of haystack.

    When offset is negative, PHP searches right to left, starting offset bytes from the end, to the start of haystack. This ignores the right side of haystack.

    Example 1:
    $foo = ‘aaaaaaaaaa’;
    var_dump(strrpos($foo, 'a', 5));
    Result: int(10)

    Example 2:
    $foo = "aaaaaa67890";
    var_dump(strrpos($foo, 'a', 5));
    Result: int(5)

    Conclusion: When offset is positive, PHP searches right to left from the end of haystack.

    Example 3:
    $foo = "aaaaa567890";
    var_dump(strrpos($foo, 'a', 5));
    Result: bool(false)

    Conclusion: When offset is positive, PHP stops searching at offset.

    Example 4:
    $foo = ‘aaaaaaaaaa’;
    var_dump(strrpos($foo, 'a', -5));
    Result: int(6)

    Conclusion: When offset is negative, PHP searches right to left, starting offset bytes from the end.

    Example 5:
    $foo = "a234567890";
    var_dump(strrpos($foo, 'a', -5));
    Result: int(0)

    Conclusion: When offset is negative, PHP searches right to left, all the way to the start of haystack.
    up
    6
    Daniel Brinca
    17 years ago
    Here is a simple function to find the position of the next occurrence of needle in haystack, but searching backwards  (lastIndexOf type function):

    //search backwards for needle in haystack, and return its position
    function rstrpos ($haystack, $needle, $offset){
        $size = strlen ($haystack);
        $pos = strpos (strrev($haystack), $needle, $size - $offset);
       
        if ($pos === false)
            return false;
       
        return $size - $pos;
    }

    Note: supports full strings as needle
    up
    0
    islandispeace at hotmail dot com
    8 years ago
    $offset is very misleading, here is my understanding:

    function mystrrpos($haystack, $needle, $offset = 0) {
        if ($offset == 0) {
            return strrpos ($haystack, $needle);
        } else {
            return strrpos (substr($haystack, 0, $offset), $needle);
        }
    }
    up
    0
    dmitry dot polushkin at gmail dot com
    18 years ago
    Returns the filename's string extension, else if no extension found returns false.
    Example: filename_extension('some_file.mp3'); // mp3
    Faster than the pathinfo() analogue in two times.
    <?php
    function filename_extension($filename) {
            $pos = strrpos($filename, '.');
        if(    $pos===false) {
            return     false;
        } else {
            return     substr($filename, $pos+1);
        }
    }
    ?>
    up
    0
    fab
    19 years ago
    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;
    }

    ?>
    up
    -1
    escii at hotmail dot com ( Brendan )
    19 years ago
    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;
    }
    ?>
    up
    -2
    arlaud pierre
    12 years ago
    This seems to behave like the exact equivalent to the PHP 5 offset parameter for a PHP 4 version.

    <?php
    function strrpos_handmade($haystack, $needle, $offset = 0){

      if(    $offset === 0) return strrpos($haystack, $needle);
     
          $length = strlen($haystack);
          $size = strlen($needle);

      if(    $offset < 0) {
            $virtual_cut = $length+$offset;
            $haystack = substr($haystack, 0, $virtual_cut+$size);
            $ret = strrpos($haystack, $needle);
        return     $ret > $virtual_cut ? false : $ret;
      } else {
            $haystack = substr($haystack, $offset);
            $ret = strrpos($haystack, $needle);
        return     $ret === false ? $ret : $ret+$offset;
      }

    }
    ?>
    up
    -1
    gordon at kanazawa-gu dot ac dot jp
    19 years ago
    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;
    }
    up
    -1
    shimon at schoolportal dot co dot il
    18 years ago
    In strrstr function in php 4 there is also no offset.
    <?
    // by Shimon Doodkin
    function chrrpos($haystack, $needle, $offset=false)
    {
    $needle=$needle[0];
    $l=strlen($haystack);
    if(    $l==0)  return false;
    if(    $offset===false)  $offset=$l-1;
    else
    {
      if(    $offset>$l) $offset=$l-1;
      if(    $offset<0) return false;
    }
    for(;    $offset>0;$offset--)
      if(    $haystack[$offset]==$needle)
       return     $offset;
    return     false;
    }
    ?>
    up
    -1
    anonymous
    4 years ago
    There is a lot of confusion around how $offset works and I feel it's really quite simple.

    If $offset is positive, the operation ignores the first $offset characters of the haystack.
    If $offset is negative, the operation ignores the last $offset-1 characters of the haystack (don't ask why -1...).

    To understand this instinctively, just imagine the characters being replaced with invalid symbols. Here's an example:

    <?php
    $hackstack     = '0123456789';

    // Search the entire sequence 0123456789
    var_dump(strrpos($hackstack, '0')); // int(0)
    var_dump(strrpos($hackstack, '9')); // int(9)

    // Only search ##23456789
    var_dump(strrpos($hackstack, '1', 2)); // bool(false)
    var_dump(strrpos($hackstack, '2', 2)); // int(2)

    // Only search 0123456###
    var_dump(strrpos($hackstack, '6', -4)); // int(6)
    var_dump(strrpos($hackstack, '7', -4)); // bool(false)

    ?>
    up
    -2
    su.noseelg@naes, only backwards
    21 years ago
    Maybe I'm the only one who's bothered by it, but it really bugs me when the last line in a paragraph is a single word. Here's an example to explain what I don't like:

    The quick brown fox jumps over the lazy
    dog.

    So that's why I wrote this function. In any paragraph that contains more than 1 space (i.e., more than two words), it will replace the last space with '&nbsp;'.

    <?php
    function no_orphans($TheParagraph) {
        if (    substr_count($TheParagraph," ") > 1) {
            $lastspace = strrpos($TheParagraph," ");
            $TheParagraph = substr_replace($TheParagraph,"&nbsp;",$lastspace,1);
        }
    return     $TheParagraph;
    }
    ?>

    So, it would change "The quick brown fox jumps over the lazy dog." to "The quick brown fox jumps over the lazy&nbsp;dog." That way, the last two words will always stay together.
    up
    -4
    maxmike at gmail dot com
    15 years ago
    I've got a simple method of performing a reverse strpos which may be of use.  This version I have treats the offset very simply:
    Positive offsets search backwards from the supplied string index.
    Negative offsets search backwards from the position of the character that many characters from the end of the string.

    Here is an example of backwards stepping through instances of a string with this function:

    <?php
    function backwardStrpos($haystack, $needle, $offset = 0){
            $length = strlen($haystack);
            $offset = ($offset > 0)?($length - $offset):abs($offset);
            $pos = strpos(strrev($haystack), strrev($needle), $offset);
        return (    $pos === false)?false:( $length - $pos - strlen($needle) );
    }

    $pos = 0;
    $count = 0;
    echo     "Test1<br/>";
    while((    $pos = backwardStrpos("012340567890", "0", $pos)) !== false){
         echo     $pos."<br/>";
            $pos--;
        if(    $pos < 0){
            echo     "Done<br/>";break;
        }
    }
    echo     "---===---<br/>\nTest2<br/>";
    echo     backwardStrpos("12341234", "1", 2)."<br/>";
    echo     backwardStrpos("12341234", "1", -2);
    ?>

    Outputs:
    Test1
    11
    5
    0
    Done
    ---===---
    Test2
    0
    4

    With Test2 the first line checks from the first 3 in "12341234" and runs backwards until it finds a 1 (at position 0)

    The second line checks from the second 2 in "12341234" and seeks towards the beginning for the first 1 it finds (at position 4).

    This function is useful for php4 and also useful if the offset parameter in the existing strrpos is equally confusing to you as it is for me.
    up
    -5
    alexandre at NOSPAM dot pixeline dot be
    15 years ago
    I needed to check if a variable that contains a generated folder name based on user input had a trailing slash.

    This did the trick:

    <?php
            // Detect and remove a trailing slash
            $root_folder = ((strrpos($root_folder, '/') + 1) == strlen($root_folder)) ? substr($root_folder, 0, - 1) : $root_folder;
    ?>
    up
    -4
    FIE
    21 years ago
    refering to the comment and function about lastIndexOf()...
    It seemed not to work for me the only reason I could find was the haystack was reversed and the string wasnt therefore it returnt the length of the haystack rather than the position of the last needle... i rewrote it as fallows:

    <?php
    function strlpos($f_haystack,$f_needle) {
              $rev_str = strrev($f_needle);
              $rev_hay = strrev($f_haystack);
              $hay_len = strlen($f_haystack);
              $ned_pos = strpos($rev_hay,$rev_str);
              $result  = $hay_len - $ned_pos - strlen($rev_str);
          return     $result;
    }
    ?>

    this one fallows the strpos syntax rather than java's lastIndexOf.
    I'm not positive if it takes more resources assigning all of those variables in there but you can put it all in return if you want, i dont care if i crash my server ;).

    ~SILENT WIND OF DOOM WOOSH!
    up
    -5
    jafet at g dot m dot a dot i dot l dot com
    17 years ago
    Full strpos() functionality, by yours truly.

    <?php
    function conforming_strrpos($haystack, $needle, $offset = 0)
    {
            # Why does strpos() do this? Anyway...
            if(!is_string($needle)) $needle = ord(intval($needle));
            $haystack = strval($haystack);
            # Parameters
            $hlen = strlen($haystack);
            $nlen = strlen($needle);
            # Come on, this is a feature too
            if($nlen == 0)
        {
                trigger_error(__FUNCTION__.'(): Empty delimiter.', E_USER_WARNING);
            return     false;
        }
            $offset = intval($offset);
            $hrev = strrev($haystack);
            $nrev = strrev($needle);
            # Search
            $pos = strpos($hrev, $nrev, $offset);
        if(    $pos === false) return false;
        else return     $hlen - $nlen - $pos;
    }
    ?>

    Note that $offset is evaluated from the end of the string.

    Also note that conforming_strrpos() performs some five times slower than strpos(). Just a thought.
    up
    -3
    dixonmd at gmail dot com
    16 years ago
    <?php
            $pos     = strlen(string $haystack) - strpos (strrev(string $haystack), strrev(string $needle)) - strlen(string $needle);
    ?>

             If in the needle there is more than one character then in php 4 we can use the above statement for finding the position of last occurrence of a substring in a string instead of strrpos. Because in php 4 strrpos uses the first character of the substring.

    eg :
    <?php
            $haystack     = "you you you you you";
                $needle = "you";
                $pos1 = strlen($haystack) - strpos (strrev($haystack), strrev($needle)) - strlen($needle);
            echo     $pos1 . "<br>";
                $pos2 strrpos($haystack, $needle);
            echo     $pos2 . "<br>";
    ?>
    up
    -2
    stevewa
    8 years ago
    i wanted to find a leading space BEFORE a hyphen

    Crude Oil (Dec) 51.00-56.00

    so I had to find the position of the hyphen

    then subtract that position from the length of the string (to make it a negative number)
    and then walk left toward the beginning of the string, looking for the first space before the hyphen

    ex:
    $str_position_hyphen  = strpos($line_new,"-",$str_position_spread);

    $line_new_length = strlen($line_new);

    $str_position_hyphen_from_end = $str_position_hyphen - $line_new_length;

    echo "hyphen position from end = " . $str_position_hyphen_from_end . "<br />\n";
               
               
    $str_position_space_before_hyphen  = strrpos($line_new, " ", $str_position_hyphen_from_end);

    echo "*** previous space= " . $str_position_space_before_hyphen . "<br />\n";
               
    $line_new = substr_replace($line_new, ",", $str_position_space_before_hyphen, 1  );   
       
    echo $line_new . "<br /><br />\n";
    up
    -5
    lee at 5ss dot net
    21 years ago
    I should have looked here first, but instead I wrote my own version of strrpos that supports searching for entire strings, rather than individual characters.  This is a recursive function.  I have not tested to see if it is more or less efficient than the others on the page.  I hope this helps someone!

    <?php
    //Find last occurance of needle in haystack
    function str_rpos($haystack, $needle, $start = 0){
            $tempPos = strpos($haystack, $needle, $start);
        if(    $tempPos === false){
            if(    $start == 0){
                    //Needle not in string at all
                    return false;
            }else{
                    //No more occurances found
                    return $start - strlen($needle);
            }
        }else{
                //Find the next occurance
                return str_rpos($haystack, $needle, $tempPos + strlen($needle));
        }
    }
    ?>
    up
    -4
    Christ Off
    17 years ago
    Function to truncate a string
    Removing dot and comma
    Adding ... only if a is character found

    function TruncateString($phrase, $longueurMax = 150) {
        $phrase = substr(trim($phrase), 0, $longueurMax);
        $pos = strrpos($phrase, " ");
        $phrase = substr($phrase, 0, $pos);
        if ((substr($phrase,-1,1) == ",") or (substr($phrase,-1,1) == ".")) {
            $phrase = substr($phrase,0,-1);
        }
        if ($pos === false) {
            $phrase = $phrase;
        }
        else {
            $phrase = $phrase . "...";
        }
    return $phrase;
    }
    up
    -4
    kavih7 at yahoo dot com
    18 years ago
    <?php
    ###################################################
    #
    # DESCRIPTION:
    # This function returns the last occurance of a string,
    # rather than the last occurance of a single character like
    # strrpos does. It also supports an offset from where to
    # start the searching in the haystack string.
    #
    # ARGS:
    # $haystack (required) -- the string to search upon
    # $needle (required) -- the string you are looking for
    # $offset (optional) -- the offset to start from
    #
    # RETURN VALS:
    # returns integer on success
    # returns false on failure to find the string at all
    #
    ###################################################

    function strrpos_string($haystack, $needle, $offset = 0)
    {
        if(    trim($haystack) != "" && trim($needle) != "" && $offset <= strlen($haystack))
        {
                $last_pos = $offset;
                $found = false;
            while((    $curr_pos = strpos($haystack, $needle, $last_pos)) !== false)
            {
                    $found = true;
                    $last_pos = $curr_pos + 1;
            }
            if(    $found)
            {
                return     $last_pos - 1;
            }
            else
            {
                return     false;
            }
        }
        else
        {
            return     false;
        }
    }
    ?>
    up
    -4
    jonas at jonasbjork dot net
    19 years ago
    I needed to remove last directory from an path, and came up with this solution:

    <?php

      $path_dir     = "/my/sweet/home/";
          $path_up = substr( $path_dir, 0, strrpos( $path_dir, '/', -2 ) )."/";
      echo     $path_up;

    ?>

    Might be helpful for someone..
    up
    -5
    nexman at playoutloud dot net
    20 years ago
    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.
    up
    -5
    php dot net at insite-out dot com
    21 years ago
    I was looking for the equivalent of Java's lastIndexOf(). I couldn't find it so I wrote this:

    <?php
    /*
    Method to return the last occurrence of a substring within a
    string
    */
    function last_index_of($sub_str,$instr) {
        if(    strstr($instr,$sub_str)!="") {
            return(    strlen($instr)-strpos(strrev($instr),$sub_str));
        }
        return(-    1);
    }
    ?>

    It returns the numerical index of the substring you're searching for, or -1 if the substring doesn't exist within the string.
    up
    -3
    php NO at SPAMMERS willfris SREMMAPS dot ON nl
    17 years ago
    <?php
    /*******
    ** Maybe the shortest code to find the last occurence of a string, even in php4
    *******/
    function stringrpos($haystack,$needle,$offset=NULL)
    {
        return     strlen($haystack)
               -     strpos( strrev($haystack) , strrev($needle) , $offset)
               -     strlen($needle);
    }
    // @return   ->   chopped up for readability.
    ?>
    up
    -3
    ZaraWebFX
    21 years ago
    this could be, what derek mentioned:

    <?
    function cut_last_occurence($string,$cut_off) {
        return     strrev(substr(strstr(strrev($string), strrev($cut_off)),strlen($cut_off)));
    }   

    //    example: cut off the last occurence of "limit"
            $str = "select delta_limit1, delta_limit2, delta_limit3 from table limit 1,7";
            $search = " limit";
        echo     $str."\n";
        echo     cut_last_occurence($str,"limit");
    ?>
    up
    -6
    griffioen at justdesign dot nl
    19 years ago
    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;
        }
    up
    -4
    mijsoot_at_gmail_dot_com
    17 years ago
    To begin, i'm sorry for my English.
    So, I needed of one function which gives me the front last position of a character.
    Then I said myself that it should be better to make one which gives the "N" last position.

    $return_context = "1173120681_0__0_0_Mijsoot_Thierry";

    // Here i need to find = "Mijsoot_Thierry"

    //echo $return_context."<br />";// -- DEBUG

    function findPos($haystack,$needle,$position){
        $pos = strrpos($haystack, $needle);
        if($position>1){
            $position --;
            $haystack = substr($haystack, 0, $pos);
            $pos = findPos($haystack,$needle,$position);
        }else{
            // echo $haystack."<br />"; // -- DEBUG
            return $pos;
        }
        return $pos;
    }

    var_dump(findPos($return_context,"_",2)); // -- TEST
    up
    -4
    genetically altered mastermind at gmail
    19 years ago
    Very handy to get a file extension:
    $this->data['extension'] = substr($this->data['name'],strrpos($this->data['name'],'.')+1);
    up
    -4
    tsa at medicine dot wisc dot edu
    20 years ago
    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;
       }
    }
    ?>
    up
    -5
    purpleidea
    17 years ago
    I was having some issues when I moved my code to run it on a different server.
    The earlier php version didn't support more than one character needles, so tada, bugs. It's in the docs, i'm just pointing it out in case you're scratching your head for a while.
    up
    -6
    info at qrworld dot net
    10 years ago
    I made a function using strrpos to get the extension of a file.

    function getExtension($file) {
      $pos = strrpos($file, '.');
      if($pos===false){
        return false;
      } else { 
        return substr($file, $pos+1);
      }
    }

    The link of the post where I took the code is:

    http://softontherocks.blogspot.com/2013/07/obtener-la-extension-de-un-fichero-con.html
    up
    -6
    pb at tdcspace dot dk
    17 years ago
    what the hell are you all doing. Wanna find the *next* last from a specific position because strrpos is useless with the "offset" option, then....

    ex: find 'Z' in $str from position $p,  backward...

    while($p > -1 and $str{$p} <> 'Z') $p--;

    Anyone will notice $p = -1 means: *not found* and that you must ensure a valid start offset in $p, that is >=0 and < string length. Doh
    up
    -6
    tremblay dot jf at gmail dot com
    10 years ago
    I created an easy function that search a substring inside a string.
    It reverse the string and the substring inside an strpos and substract the result to the length of the string.

    if (!function_exists("real_strrpos")) {
       function real_strrpos($haystack,$needle) {
          $pos  = strlen($haystack);
          $pos -= strpos(strrev($haystack), strrev($needle) );
          $pos -= strlen($needle);
          return $pos;
       }
    }
    add a note add a note
    To Top