Javascript：负向后看等效吗？

遵循Mijoja的想法，并借鉴JasonS暴露的问题，我有了这个想法；我检查了一下，但不确定自己，所以在js正则表达式中由比我更专业的人进行验证将是很棒的:)

var re = /(?=(..|^.?)(ll))/g
         // matches empty string position
         // whenever this position is followed by
         // a string of length equal or inferior (in case of "^")
         // to "lookbehind" value
         // + actual value we would want to match

,   str = "Fall ball bill balll llama"

,   str_done = str
,   len_difference = 0
,   doer = function (where_in_str, to_replace)
    {
        str_done = str_done.slice(0, where_in_str + len_difference)
        +   "[match]"
        +   str_done.slice(where_in_str + len_difference + to_replace.length)

        len_difference = str_done.length - str.length
            /*  if str smaller:
                    len_difference will be positive
                else will be negative
            */

    }   /*  the actual function that would do whatever we want to do
            with the matches;
            this above is only an example from Jason's */



        /*  function input of .replace(),
            only there to test the value of $behind
            and if negative, call doer() with interesting parameters */
,   checker = function ($match, $behind, $after, $where, $str)
    {
        if ($behind !== "ba")
            doer
            (
                $where + $behind.length
            ,   $after
                /*  one will choose the interesting arguments
                    to give to the doer, it's only an example */
            )
        return $match // empty string anyhow, but well
    }
str.replace(re, checker)
console.log(str_done)

我的个人输出：

Fa[match] ball bi[match] bal[match] [match]ama

原理是checker在字符串中任意两个字符之间的每个点处调用，只要该位置是以下位置的起点：

---任何不需要的大小的子字符串（此处'ba'为..）（如果知道该大小，否则可能很难做）

--- ---或更小（如果它是字符串的开头）： ^.?

然后，

---实际要查找的内容（在此处'll'）。

在每次调用时checker，都会进行测试，以检查之前的值ll是否不是我们不想要的值（!== 'ba'）；如果是这样，我们将调用另一个函数，并且必须使用这个（doer）才能在str上进行更改，如果目的是这个（或更笼统地说），则将输入必要的数据以进行手动处理扫描的结果str。

在这里，我们更改了字符串，因此我们需要跟踪长度的差异，以便偏移所给定的位置replace，这些位置都是在上计算的str，而该位置本身从未改变。

由于原始字符串是不可变的，因此我们可以使用该变量str存储整个操作的结果，但是我认为该示例由于替换而已经很复杂，使用另一个变量（str_done）会更清楚。

我猜在性能上一定很苛刻：所有无意义地将“”替换为“” this str.length-1，再加上执行者手动替换，这意味着需要大量切片……在上述特定情况下，可能通过仅将字符串切成一小段的方式将其分组，使其围绕我们要插入的位置[match]并与.join()它[match]自身对齐。

另一件事是，我不知道它将如何处理更复杂的情况，也就是说，伪造后视的复杂值……长度可能是要获取的最有问题的数据。

并且，在中checker，如果$ behind的非期望值有多种可能性，我们将不得不使用另一个正则表达式（要在外部进行缓存（创建））进行测试checker，以避免生成相同的正则表达式对象在每次调用checker）时都知道它是否是我们想要避免的东西。

希望我已经清楚了；如果不犹豫，我会尽力而为。:)

"jim jam".replace(/([^a-g])m/g, "$1M")
\\jiM jam

function TestSORegEx() {
  var s = "Donald Trump doesn't like jam, but Homer Simpson does.";
  var reg = /(?![abcdefg])(.{1})(m)/gm;
  var out = "Matches and groups of the regex " + 
            "/(?![abcdefg])(.{1})(m)/gm in \ns = \"" + s + "\"";
  var match = reg.exec(s);
  while(match) {
    var start = match.index + match[1].length;
    out += "\nWhole match: " + match[0] + ", starts at: " + match.index
        +  ". Desired match: " + match[2] + ", starts at: " + start + ".";   
    match = reg.exec(s);
  }
  out += "\nResulting string after statement s.replace(reg, \"$1*$2*\")\n"
         + s.replace(reg, "$1*$2*");
  alert(out);
}

"jim".match(/[^a-g]m/)
> ["im"]
"jam".match(/[^a-g]m/)
> null

"jim jam".replace(/([^a-g])m/g, "$1M")
> "jiM jam"