Javascript Lookbehind with Global Search Overlapped
There are several (sometimes tricky) solutions for lookbehind regex in Javascript. But, which is the easiest way if I want zero width! , look for a globally searched expression that can overlap. For example. using /(?<=[01])\d/g
, we could do the following:
var a = "--1--01001--1087---";
a.replace(/(?<=[01])\d/g, "#");
// This should return "--1--0####--1##7---" if lookbehind would be supported
Or another example: how can we create a type expression \b
that only works with letters ( [a-zA-Z]
). (Lookforward is not a question. It's just that JS doesn't support lookbehind).
source to share
The reverse approach looks simpler. This approach is best for short numeric patterns like this.
function revStr(str) {
return str.split('').reverse().join('');
}
var s = "--1--01001--1087---";
var rxp = /\d(?=[01])/g;
var result = revStr(revStr(s).replace(rxp, "#"));
document.write(result);
Logics:
-
\d(?=[01])
is the reverse regex for(?<=[01])\d
- We invert the input string with the function
revStr(s)
- We return the replacement result again to get the final result.
Note
If you want both a variable width look and feel in JavaScript, I can recommend reading JavaScript Regex Lookbehind Redux by Stephen Levitan, where you can find a sample function showing how to implement this behavior using XRegExp . Here are the functions:
// Simulating infinite-length leading lookbehind in JavaScript. Uses XRegExp.
// Captures within lookbehind are not included in match results. Lazy
// repetition in lookbehind may lead to unexpected results.
(function (XRegExp) {
function prepareLb(lb) {
// Allow mode modifier before lookbehind
var parts = /^((?:\(\?[\w$]+\))?)\(\?<([=!])([\s\S]*)\)$/.exec(lb);
return {
// $(?!\s) allows use of (?m) in lookbehind
lb: XRegExp(parts ? parts[1] + "(?:" + parts[3] + ")$(?!\\s)" : lb),
// Positive or negative lookbehind. Use positive if no lookbehind group
type: parts ? parts[2] === "=" : !parts
};
}
XRegExp.execLb = function (str, lb, regex) {
var pos = 0, match, leftContext;
lb = prepareLb(lb);
while (match = XRegExp.exec(str, regex, pos)) {
leftContext = str.slice(0, match.index);
if (lb.type === lb.lb.test(leftContext)) {
return match;
}
pos = match.index + 1;
}
return null;
};
XRegExp.testLb = function (str, lb, regex) {
return !!XRegExp.execLb(str, lb, regex);
};
XRegExp.searchLb = function (str, lb, regex) {
var match = XRegExp.execLb(str, lb, regex);
return match ? match.index : -1;
};
XRegExp.matchAllLb = function (str, lb, regex) {
var matches = [], pos = 0, match, leftContext;
lb = prepareLb(lb);
while (match = XRegExp.exec(str, regex, pos)) {
leftContext = str.slice(0, match.index);
if (lb.type === lb.lb.test(leftContext)) {
matches.push(match[0]);
pos = match.index + (match[0].length || 1);
} else {
pos = match.index + 1;
}
}
return matches;
};
XRegExp.replaceLb = function (str, lb, regex, replacement) {
var output = "", pos = 0, lastEnd = 0, match, leftContext;
lb = prepareLb(lb);
while (match = XRegExp.exec(str, regex, pos)) {
leftContext = str.slice(0, match.index);
if (lb.type === lb.lb.test(leftContext)) {
// Doesn't work correctly if lookahead in regex looks outside of the match
output += str.slice(lastEnd, match.index) + XRegExp.replace(match[0], regex, replacement);
lastEnd = match.index + match[0].length;
if (!regex.global) {
break;
}
pos = match.index + (match[0].length || 1);
} else {
pos = match.index + 1;
}
}
return output + str.slice(lastEnd);
};
}(XRegExp));
Each of these functions takes three arguments: a string to search for, a lookbehind pattern as a string (can use XRegExp syntax extensions), and a basic regular expression. XRegExp.replaceLb
takes a fourth argument for the replacement value, which can be a string or a function.
Below are examples of use:
XRegExp.execLb("Fluffy cat", "(?i)(?<=fluffy\\W+)", XRegExp("(?i)(?<first>c)at"));
// -> ["cat", "c"]
// Result has named backref: result.first -> "c"
XRegExp.execLb("Fluffy cat", "(?i)(?<!fluffy\\W+)", /cat/i);
// -> null
XRegExp.testLb("Fluffy cat", "(?i)(?<=fluffy\\W+)", /cat/i);
// -> true
XRegExp.testLb("Fluffy cat", "(?i)(?<!fluffy\\W+)", /cat/i);
// -> false
XRegExp.searchLb("Catwoman fluffy cat", "(?i)(?<=fluffy\\W+)", /cat/i);
// -> 18
XRegExp.searchLb("Catwoman fluffy cat", "(?i)(?<!fluffy\\W+)", /cat/i);
// -> 0
XRegExp.matchAllLb("Catwoman cats are fluffy cats", "(?i)(?<=fluffy\\W+)", /cat\w*/i);
// -> ["cats"]
XRegExp.matchAllLb("Catwoman cats are fluffy cats", "(?i)(?<!fluffy\\W+)", /cat\w*/i);
// -> ["Catwoman", "cats"]
XRegExp.replaceLb("Catwoman fluffy cat is a cat", "(?i)(?<=fluffy\\W+)", /cat/ig, "dog");
// -> "Catwoman fluffy dog is a cat"
XRegExp.replaceLb("Catwoman fluffy cat is a cat", "(?i)(?<!fluffy\\W+)", /cat/ig, "dog");
// -> "dogwoman fluffy cat is a dog"
XRegExp.replaceLb("Catwoman fluffy cat is a cat", "(?i)(?<!fluffy\\W+)", /cat/ig, function ($0) {
var first = $0.charAt(0);
return first === first.toUpperCase() ? "Dog" : "dog";
});
// -> "Dogwoman fluffy cat is a dog"
source to share