Javascript：正则表达式的字符串搜索，从字符串的末尾开始

Question

是否有一个 javascript string 函数，search 是一个正则表达式，它会在最后开始搜索？

如果不是，从末尾开始搜索正则表达式索引的最快和/或最简洁的方法是什么？

正则表达式示例：

/<\/?([a-z][a-z0-9]*)\b[^>]*>?/gi

Answer 1

您可以创建一个反向函数，如：

function reverse (s) {
  var o = '';
  for (var i = s.length - 1; i >= 0; i--)
    o += s[i];
  return o;
}

然后使用

var yourString = reverse("Your string goes here");
var regex = new Regex(your_expression);
var result = yourString.match(regex);

---

另一个想法：如果你想按单词倒序搜索，那么

function reverseWord(s) {
   var o = '';
   var split = s.split(' ');

  for (var i = split.length - 1; i >= 0; i--)
    o += split[i] + ' ';
  return o;
}

var yourString = reverseWord("Your string goes here");
var regex = new Regex(your_expression);
var result = yourString.match(regex);

Answer 2

这取决于您究竟想要搜索什么。您可以使用string.lastIndexOf 或在正则表达式中使用$（字符串结尾）。

更新： 试试正则表达式

/<\/?([a-z][a-z0-9]*)\b[^>]*>?[\w\W]*$/gi

Answer 3

假设你正在寻找一个字符串'token'，那么你需要'token'的位置，直到字符串末尾没有其他'token'。

所以你应该像这样编写你的正则表达式：

$token = 'token';
$re = "/(?:$token)[^(?:$token)]*$/";

这将找到您的“令牌”，直到字符串结束才能找到进一步的“令牌”。 "(?:" 分组只是使组不存储，稍微加快性能并节省内存。

Answer 4

Andreas 从评论中给出了这个：

https://stackoverflow.com/a/274094/402037

String.prototype.regexLastIndexOf = function(regex, startpos) {
    regex = (regex.global) ? regex : new RegExp(regex.source, "g" + (regex.ignoreCase ? "i" : "") + (regex.multiLine ? "m" : ""));
    if(typeof (startpos) == "undefined") {
        startpos = this.length;
    } else if(startpos < 0) {
        startpos = 0;
    }
    var stringToWorkWith = this.substring(0, startpos + 1);
    var lastIndexOf = -1;
    var nextStop = 0;
    while((result = regex.exec(stringToWorkWith)) != null) {
        lastIndexOf = result.index;
        regex.lastIndex = ++nextStop;
    }
    return lastIndexOf;
}

它提供了我需要的功能，我测试了我的正则表达式，它是成功的。所以我会用这个

Answer 5

var m = text.match(/.*(<\/?([a-z][a-z0-9]*)\b[^>]*>?)/i);
if (m) {
    textFound = m[1];
    position = text.lastIndexOf(textFound);
}

使用 .* 跳过尽可能多的文本，捕获找到的文本并使用 lastIndexOf 进行搜索

编辑：

好吧，如果找到文本，则无需使用 lastIndexOf 进行搜索。 m[0] 包含全部重合（包括所有初始填充），m[1] 包含搜索到的文本。所以找到的文本的位置是 m[0].length - m[1].length

var m = text.match(/.*(<\/?([a-z][a-z0-9]*)\b[^>]*>?)/i);
if (m) {
    textFound = m[1];
    position = m[0].length - m[1].length;
}

Answer 6

也许这样的东西适合你？

Javascript

function lastIndexOfRx(string, regex) {
    var match = string.match(regex);

    return  match ? string.lastIndexOf(match.slice(-1)) : -1;
}

var rx = /<\/?([a-z][a-z0-9]*)\b[^>]*>?/gi;

console.log(lastIndexOfRx("", rx));
console.log(lastIndexOfRx("<i>it</i><b>bo</b>", rx));

jsFiddle

仅出于兴趣，此功能与您选择使用的功能。 jsperf

这要求您正确格式化您的正则表达式以完全匹配您想要的全局模式（如您的问题中给出的），例如/.*(<\/?([a-z][a-z0-9]*)\b[^>]*>?)/i 将不适用于此功能。但是你得到的是一个干净而快速的功能。

Answer 7

也许这会更有用且更容易：

str.lastIndexOf(str.match(<your_regex_here>).pop());