For example a regExp that searches for non-word matches in plain text:

/(<|>|::|–|@|###)/

could be sped up by adding an additional chew-up blind-match:

/(<|>|::|–|@|###)|[^<>:-@#]+/

The chew-up blind-match has then to be filtered out (e.g. as an empty match).

This also works for matches containing words:

/\b(http:|ftp:|gopher:)/

becomes:

/\b(http:|ftp:|gopher:)|\b[^:]{7,}/

I had a gigantic regExp to parse wiki code for syntax highlighting, consisting of “|”-separated subexpressions for all existing wiki codes. Just by adding a chew-up expression I cut the execution time in half (the code is for the Wikipedia editor wikEd and I was using JavaScript under Firefox 3.5).

Because I write a lexical analysis routine in JS, there are potentially a lot of regex tests being run on a long input source, many of which won’t match at all, but nevertheless the regexp engine will scan the whole string.

The solution? Limit the size of the input to the first N characters of your input. If there’s no match, forget it. If there’s a match and its length is exactly equal to N, re-run the match against the full string (since you may have accidentally truncated it).

Even though this now means you may be regexing more times than without a limit, you are scanning less data each time.

This cut my execution time down massively. For 11KB of JavaScript source lexing it took 1500ms on Safari 3 and 650ms on FF3. I tried all sorts and was on the verge of giving up (what use is a lexical analyzer that’s going to take so long to execute?).

With input size limits imposed this came down to 120ms in Safari and 300ms in FF (the tables turned in terms of which browser was faster).

There are other optimizations I need to find now (string buffering & traversing), but that by far will be the biggest I’ll resolve

This is the relevant code:
* (self is a copy of the reference to “this”)
* self.In is the input source (it gets eaten from left-to-right so the start is the important bit)
* The RegExp (re) has been optimized to inject the caret “^” to the start
* _minInputSize is the optimization factor. I default to 32 chars of input.
——————————–
/** @private */
var _scanByRegExp = function _scanByRegExp(re) {
var match = ”;
var matches;
if ((matches = re.exec(self.In.substring(0, _minInputSize)))
&& matches.index == 0) {
match = matches[0];

//FSA optimization check:
//If it looks like there’s more of this token, try without the limit
if (match.length == _minInputSize) {
matches = re.exec(self.In);
match = matches[0];
}
}
return match;
};
————————————-

have a good weekend.
j

Just replace the text you match with an empty string, and what’s left will be the part you want to keep, e.g.:

str = str.replace(/#.*/, "");

Or in this case you could also use str = str.match(/^[^#]*/)[0];

However, for the case you described you don’t really need to use a regex. Try this instead:

str = str.substring(0, str.indexOf("#"));