(PHP 4, PHP 5, PHP 7, PHP 8)
strrpos — 查找子字符串在字符串中最后一次出现的 位置
查找 needle 在 haystack 字符串中最后一次出现的数值位置。
haystack要搜索的字符串。
needle要搜索的字符串。
在 PHP 8.0.0 之前，如果 needle 不是字符串，则将其转换为整数并应用为字符的序数值。 从 PHP 7.3.0 开始，此行为已弃用，强烈建议不要依赖此行为。 根据预期行为，needle 应该显式转换为字符串，或者应该显式调用 chr()。
offset如果为零或正数，则搜索将从左到右进行，跳过 haystack 的前 offset 个字节。
如果为负数，则搜索将从 haystack 的末尾开始向左 offset 个字节进行。 搜索将从右到左进行，从选定的字节开始查找 needle 的第一次出现。
注意:
这实际上是在查找
haystack最后offset个字节处或之前needle的最后一次出现。
示例 #1 检查 needle 是否在 haystack 中
很容易将返回值误认为是“在位置 0 处找到的字符”和“未找到字符”。 以下是区分它们的方法
<?php
$pos = strrpos($mystring, "b");
if ($pos === false) { // 注意：三个等号
// 未找到...
}
?>
示例 #2 使用偏移量搜索
<?php
$foo = "0123456789a123456789b123456789c";
// 从第 0 个字节（从开头）开始查找 '0'
var_dump(strrpos($foo, '0', 0));
// 从第 1 个字节（在字节 "0" 之后）开始查找 '0'
var_dump(strrpos($foo, '0', 1));
// 从第 21 个字节（在字节 20 之后）开始查找 '7'
var_dump(strrpos($foo, '7', 20));
// 从第 29 个字节（在字节 28 之后）开始查找 '7'
var_dump(strrpos($foo, '7', 28));
// 从末尾开始向左 5 个字节开始查找 '7'
var_dump(strrpos($foo, '7', -5));
// 从末尾开始向左 2 个字节开始查找 'c'
var_dump(strrpos($foo, 'c', -2));
// 从末尾开始向左 2 个字节开始查找 '9c'
var_dump(strrpos($foo, '9c', -2));
?>上面的示例将输出
int(0) bool(false) int(27) bool(false) int(17) bool(false) int(29)
'offset' 的文档有误导性。
它说，“可以指定偏移量以开始在字符串中搜索任意数量的字符。 负值将在字符串结束前的任意点停止搜索。”
如果你认为 strrpos 是从字符串末尾开始向后工作，这会令人困惑。
更好的理解偏移量的方式是
- 如果偏移量为正数，则 strrpos 仅对字符串中从偏移量到末尾的部分进行操作。 这通常与不指定偏移量具有相同的结果，除非 needle 的唯一出现位置在偏移量之前（在这种情况下，指定偏移量将找不到 needle）。
- 如果偏移量为负数，则 strrpos 仅对字符串末尾的那些字符进行操作。 如果 needle 距离字符串末尾更远，则不会找到它。
例如，如果你想在第 50 个字符之前的字符串中找到最后一个空格，你需要做类似这样的操作
strrpos($text, " ", -(strlen($text) - 50));
如果你改为使用 strrpos($text, " ", 50)，那么你会在第 50 个字符和字符串末尾之间找到最后一个空格，这可能不是你的本意。十年过去了，Brian 的笔记仍然是对偏移量如何工作的很好概述，但更短更简单的总结是
strrpos($x, $y, 50); // 1: 这告诉 strrpos() 何时停止，从 $x 的开头开始计数
strrpos($x, $y, -50); // 2: 这告诉 strrpos() 何时开始，从 $x 的末尾开始计数
或者换句话说，正数允许你搜索字符串的最右侧部分，而负数允许你搜索字符串的最左侧部分。
这两个变体都有用，但选错可能会导致非常令人困惑的结果！对偏移的描述是错误的。以下是它的工作原理，以及支持的示例。
偏移会影响搜索的起点和终点。方向始终是从右到左。（描述错误地说，当偏移为正数时，PHP 从左到右搜索。）
以下是它的工作原理
当偏移为正数时，PHP 从 haystack 的末尾到偏移位置从右到左搜索。这会忽略 haystack 的左侧。
当偏移为负数时，PHP 从右到左搜索，从末尾的偏移字节开始，到 haystack 的开头。这会忽略 haystack 的右侧。
示例 1
$foo = ‘aaaaaaaaaa’;
var_dump(strrpos($foo, 'a', 5));
结果：int(10)
示例 2
$foo = "aaaaaa67890";
var_dump(strrpos($foo, 'a', 5));
结果：int(5)
结论：当偏移为正数时，PHP 从 haystack 的末尾从右到左搜索。
示例 3
$foo = "aaaaa567890";
var_dump(strrpos($foo, 'a', 5));
结果：bool(false)
结论：当偏移为正数时，PHP 在偏移位置停止搜索。
示例 4
$foo = ‘aaaaaaaaaa’;
var_dump(strrpos($foo, 'a', -5));
结果：int(6)
结论：当偏移为负数时，PHP 从右到左搜索，从末尾的偏移字节开始。
示例 5
$foo = "a234567890";
var_dump(strrpos($foo, 'a', -5));
结果：int(0)
结论：当偏移为负数时，PHP 从右到左搜索，一直到 haystack 的开头。以下是一个简单的函数，用于查找 needle 在 haystack 中下一次出现的 位置，但向后搜索（lastIndexOf 类型函数）
// 向后搜索 haystack 中的 needle，并返回其位置
function rstrpos ($haystack, $needle, $offset){
$size = strlen ($haystack);
$pos = strpos (strrev($haystack), $needle, $size - $offset);
if ($pos === false)
return false;
return $size - $pos;
}
注意：支持完整字符串作为 needle关于 $offset 的工作原理有很多困惑，我觉得它其实很简单。
如果 $offset 为正数，则操作会忽略 haystack 中的前 $offset 个字符。
如果 $offset 为负数，则操作会忽略 haystack 中的最后 $offset-1 个字符（不要问为什么是 -1...）。
要直观地理解这一点，只需想象将这些字符替换为无效符号。以下是一个示例
<?php
$hackstack = '0123456789';
// 搜索整个序列 0123456789
var_dump(strrpos($hackstack, '0')); // int(0)
var_dump(strrpos($hackstack, '9')); // int(9)
// 仅搜索 ##23456789
var_dump(strrpos($hackstack, '1', 2)); // bool(false)
var_dump(strrpos($hackstack, '2', 2)); // int(2)
// 仅搜索 0123456###
var_dump(strrpos($hackstack, '6', -4)); // int(6)
var_dump(strrpos($hackstack, '7', -4)); // bool(false)
?>我想在连字符之前找到一个前导空格
原油（12 月）51.00-56.00
所以我必须找到连字符的位置
然后从字符串的长度中减去该位置（使其变为负数）
然后向左走到字符串的开头，寻找连字符之前的第一个空格
例如
$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";$offset 非常具有误导性，以下是我对它的理解
function mystrrpos($haystack, $needle, $offset = 0) {
if ($offset == 0) {
return strrpos ($haystack, $needle);
} else {
return strrpos (substr($haystack, 0, $offset), $needle);
}
}返回文件名字符串扩展名，否则如果未找到扩展名则返回 false。
示例：filename_extension('some_file.mp3'); // mp3
比 pathinfo() 模拟快两倍。
<?php
function filename_extension($filename) {
$pos = strrpos($filename, '.');
if($pos===false) {
return false;
} else {
return substr($filename, $pos+1);
}
}
?>当我发现 strrpos 的行为方式时，我立刻很生气（它不应该被称为 charrpos 吗？），所以我创建了自己的实现来搜索字符串。
<?
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;
}
?>RE: hao2lian
此页面上有很多 strrpos() 的替代实现，而且不幸的是，这些实现都有错误（或者被称为 last_index_of）。这个实现是对下面那个实现的轻微修改，但它应该像真正的 *strrpos()* 一样工作，因为它在 haystack 中没有 needle 时返回 false。
<?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;
}
?>这似乎与 PHP 4 版本的 PHP 5 偏移参数完全相同。
<?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;
}
}
?>此处建议的“查找字符串的最后出现位置”函数不允许使用起始偏移量，因此这里有一个经过尝试和测试的函数，它允许使用起始偏移量
function my_strrpos($haystack, $needle, $offset=0) {
// 与 strrpos 相同，只是 $needle 可以是字符串
$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;
}在 php 4 中的 strrstr 函数中也没有偏移量。
<?
// 作者：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;
}
?>也许只有我才会在意，但当段落的最后一行只有一个词时，我真的很困扰。以下是一个例子来解释我不喜欢什么
The quick brown fox jumps over the lazy
dog.
所以，这就是我写这个函数的原因。在任何包含多个空格（即超过两个词）的段落中，它将用“ ”替换最后一个空格。
<?php
function no_orphans($TheParagraph) {
if (substr_count($TheParagraph," ") > 1) {
$lastspace = strrpos($TheParagraph," ");
$TheParagraph = substr_replace($TheParagraph," ",$lastspace,1);
}
return $TheParagraph;
}
?>
因此，它会将“The quick brown fox jumps over the lazy dog.” 更改为 “The quick brown fox jumps over the lazy dog.”。这样，最后两个词就会始终保持在一起。我有一个简单的方法来执行反向 strpos，这可能会有用。我这里的版本非常简单地处理偏移量
正偏移量从提供的字符串索引向后搜索。
负偏移量从字符串末尾的指定字符位置向后搜索。
以下是用此函数逐步反向遍历字符串实例的示例
<?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);
?>
输出
Test1
11
5
0
Done
---===---
Test2
0
4
在 Test2 中，第一行从 "12341234" 中的第一个 3 开始，向后运行，直到找到一个 1（在位置 0）
第二行从 "12341234" 中的第二个 2 开始，向开头方向搜索，找到第一个 1（在位置 4）。
此函数适用于 php4，并且如果现有 strrpos 中的偏移量参数像对我一样令人困惑，那么它也很有用。我需要检查一个包含基于用户输入生成的文件夹名称的变量是否包含尾部斜杠。
这很管用
<?php
// 检测并删除尾部斜杠
$root_folder = ((strrpos($root_folder, '/') + 1) == strlen($root_folder)) ? substr($root_folder, 0, - 1) : $root_folder;
?>参考关于 lastIndexOf() 的注释和函数...
我发现它对我来说似乎不起作用，唯一的原因是我发现干草堆是反转的，而字符串不是，因此它返回干草堆的长度而不是最后一个针的的位置... 我把它重写如下
<?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;
}
?>
这个函数遵循 strpos 语法而不是 Java 的 lastIndexOf。
我不确定在里面分配所有这些变量是否需要更多资源，但如果你想，你可以把所有东西都放在 return 中，我不在乎我的服务器是否崩溃；）。
~寂静的末日之风呼啸而过！完整的 strpos() 功能，由我亲自制作。
<?php
function conforming_strrpos($haystack, $needle, $offset = 0)
{
# 为什么 strpos() 会这样做？无论如何...
if(!is_string($needle)) $needle = ord(intval($needle));
$haystack = strval($haystack);
# 参数
$hlen = strlen($haystack);
$nlen = strlen($needle);
# 来吧，这也是一个功能
if($nlen == 0)
{
trigger_error(__FUNCTION__.'(): Empty delimiter.', E_USER_WARNING);
return false;
}
$offset = intval($offset);
$hrev = strrev($haystack);
$nrev = strrev($needle);
# 搜索
$pos = strpos($hrev, $nrev, $offset);
if($pos === false) return false;
else return $hlen - $nlen - $pos;
}
?>
请注意，$offset 是从字符串末尾评估的。
另外请注意，conforming_strrpos() 的执行速度比 strpos() 慢约五倍。仅仅是思考而已。<?php
$pos = strlen(string $haystack) - strpos (strrev(string $haystack), strrev(string $needle)) - strlen(string $needle);
?>
如果针中有多个字符，那么在 php 4 中，我们可以使用上述语句来查找字符串中子字符串最后一次出现的的位置，而不是 strrpos。因为在 php 4 中，strrpos 使用子字符串的第一个字符。
例如
<?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>";
?>我一直在寻找 Java 中 lastIndexOf() 的等效函数。我找不到，所以我写了这个
<?php
/*
返回字符串中子字符串最后出现位置的方法
字符串
*/
function last_index_of($sub_str,$instr) {
if(strstr($instr,$sub_str)!="") {
return(strlen($instr)-strpos(strrev($instr),$sub_str));
}
return(-1);
}
?>
它返回您要搜索的子字符串的数字索引，如果子字符串不存在于字符串中，则返回 -1。首先，我很抱歉我的英语。
所以，我需要一个函数来提供字符的最后位置。
然后我对自己说，最好做一个可以提供“N”个最后位置的函数。
$return_context = "1173120681_0__0_0_Mijsoot_Thierry";
// 这里我需要找到 = "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我应该先在这里查看，但我自己写了一个 strrpos 版本，它支持搜索整个字符串，而不是单个字符。这是一个递归函数。我没有测试它是否比页面上的其他函数更高效或更低效。我希望这能帮到某人！
<?php
// 查找针在干草堆中的最后一次出现
function str_rpos($haystack, $needle, $start = 0){
$tempPos = strpos($haystack, $needle, $start);
if($tempPos === false){
if($start == 0){
// 针根本不在字符串中
return false;
}else{
// 没有找到更多出现的位置
return $start - strlen($needle);
}
}else{
// 找到下一个出现的位置
return str_rpos($haystack, $needle, $tempPos + strlen($needle));
}
}
?><?php
###################################################
#
# 描述：
# 此函数返回字符串的最后一次出现，
# 而不是像 strrpos 那样返回单个字符的最后一次出现。它还支持从哪里开始在干草堆字符串中搜索的偏移量。
#
# 参数：
# $haystack (必需) -- 要搜索的字符串
# $needle (必需) -- 您要查找的字符串
# $offset (可选) -- 要从哪里开始的偏移量
#
# 返回值：
# 成功时返回整数
# 在完全找不到字符串时返回 false
#
###################################################
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;
}
}
?>我需要从路径中删除最后一个目录，并找到了这个解决方案
<?php
$path_dir = "/my/sweet/home/";
$path_up = substr( $path_dir, 0, strrpos( $path_dir, '/', -2 ) )."/";
echo $path_up;
?>
可能对某人有用..截断字符串的函数
删除点和逗号
仅在找到字符时添加 ...
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;
}类似于 5.0 版本的 strrpos 的 4.x 版本的函数。
这将返回字符串中字符串的*最后*一次出现。
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;
}
如果我的数学计算错误，请随时更正。
- 正偏移量将是允许的第一个字符的最小字符索引位置。
- 负偏移量将从总长度中减去，并且之前的直接位置将是搜索的第一个字符的最大索引。
返回针的最后一次出现的字符索引（0+）。
* 布尔值 FALSE 将在干草堆中返回没有匹配项，或者在偏移量指定的边界之外。这可能是，德里克提到的内容
<?
function cut_last_occurence($string,$cut_off) {
return strrev(substr(strstr(strrev($string), strrev($cut_off)),strlen($cut_off)));
}
// 例如：切断 "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");
?>如果您希望在字符串中查找字符串的最后一次出现（而不是单个字符），并且没有使用 mb_strrpos，请尝试以下操作
function lastIndexOf($haystack, $needle) {
$index = strpos(strrev($haystack), strrev($needle));
$index = strlen($haystack) - strlen(index) - $index;
return $index;
}<?php
/*******
** 查找字符串最后出现位置的最短代码，即使在 php4 中也是如此
*******/
function stringrpos($haystack,$needle,$offset=NULL)
{
return strlen($haystack)
- strpos( strrev($haystack) , strrev($needle) , $offset)
- strlen($needle);
}
// @return -> 为可读性而分割。
?>非常方便获取文件扩展名
$this->data['extension'] = substr($this->data['name'],strrpos($this->data['name'],'.')+1);天啊，我想我会在混合中添加另一个函数。它并不漂亮，但以下函数从您的起点倒数并告诉您混合字符字符串的最后一次出现
<?php
function strrposmixed ($haystack, $needle, $start=0) {
// 如果未设置，则将 start 初始化为字符串的结尾
if($start == 0) {
$start = strlen($haystack);
}
// 从 $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;
}
}
?>我使用 strrpos 创建了一个函数来获取文件的扩展名。
function getExtension($file) {
$pos = strrpos($file, '.');
if($pos===false){
return false;
} else {
return substr($file, $pos+1);
}
}
我获取代码的帖子链接是
http://softontherocks.blogspot.com/2013/07/obtener-la-extension-de-un-fichero-con.html你们到底在做什么。想要从特定位置查找 *下一个* 最后位置，因为 strrpos 在使用 “offset” 选项时毫无用处，那么……
例如：从位置 $p 向后查找 $str 中的 'Z'...
while($p > -1 and $str{$p} <> 'Z') $p--;
任何人都能注意到 $p = -1 意味着：*未找到*，并且您必须确保 $p 中的有效起始偏移量，即 >=0 且 < 字符串长度。Doh我创建了一个简单的函数，用于在字符串中搜索子字符串。
它反转字符串和子字符串，并在 strpos 中，从字符串的长度中减去结果。
if (!function_exists("real_strrpos")) {
function real_strrpos($haystack,$needle) {
$pos = strlen($haystack);
$pos -= strpos(strrev($haystack), strrev($needle) );
$pos -= strlen($needle);
return $pos;
}
}