Prevent tainting properties of the RegExp constructor in JavaScript

Question

This is a bit of a conundrum, I have an idea of how I might be able to fix it but I'm wondering if there's a (much) easier way.

In short, whenever a regular expression is executed in JavaScript, certain properties are assigned values on the RegExp constructor. For instance:

/foo/.test('football')
//-> true

RegExp.input
//-> "football"

RegExp.rightContext
//-> "tball"

I'd like to execute a regular expression without affecting these properties. If that's not possible (and I don't think it is), I'd like to at least restore them to their previous values afterwards.

I know input/$_ is writeable, but most of the others aren't, it seems. One option might be to reconstruct a regular expression that would reapply all these values, but I think that would be quite difficult.

The reason I want this is because I'm writing a shim of a native API, and testing it using the test262 suite. The test262 suite fails on certain tests where it checks to see if the RegExp object has unexpected values for these properties.

I like the conundrum that you revealed. However, my thought is that you are changing a part of your system that doesn't need to be changed to accommodate a broken part: the broken part being your testing framework. If your final product does not require that the RegExp object retain its original state, then there is no reason you should let an arbitrary test in your framework force you to rewrite your code. I would say the piece you want to change is the testing framework. I assume you looked for configuration options and such to ignore certain test on the RegExp object? — Hurricane Hamilton
– Hurricane Hamilton, Commented Jun 3, 2013 at 17:35
@Hurricane: Yeah, I could choose to ignore it, and I almost did. If the solution hadn't been so easy I probably would have. However, since I'm writing a shim for a native API I wanted it to be as close an implementation as possible to cover all bases. I have already bent the test rules in my favour a few times where this isn't possible, however. — Andy E
– Andy E, Commented Jun 3, 2013 at 20:23

Lex Podgorny · Accepted Answer · 2013-07-10 05:24:54Z

1

You can try to create a wrapper function for test:

var fTest = RegExp.test;
RegExp.test = function() {
    var bReturn = fTest.apply(RegExp, arguments);
    delete RegExp.input;
    delete RegExp.rightContext;
    return bReturn;
}

answered Jul 10, 2013 at 5:24

Lex Podgorny

3,0201 gold badge32 silver badges46 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Andy E Over a year ago

This doesn't "restore" the previous state (it just deletes those properties from the object), and doesn't work in Google Chrome where most of the properties are getters. Also, it's changing the behaviour of the built in RegExp.prototype.test method, which is undesired.

Andy E · Accepted Answer · 2014-05-19 16:03:36Z

This is the final result. It's a little more robust than my initial effort; it properly escapes sub-expressions, makes sure they appear in the right order and doesn't stop when it finds an empty one:

/**
 * Constructs a regular expression to restore tainted RegExp properties
 */
function createRegExpRestore () {
    var lm  = RegExp.lastMatch,
        ret = {
           input: RegExp.input
        },
        esc = /[.?*+^$[\]\\(){}|-]/g,
        reg = [],
        cap = {};

    // Create a snapshot of all the 'captured' properties
    for (var i = 1; i <= 9; i++)
        cap['$'+i] = RegExp['$'+i];

    // Escape any special characters in the lastMatch string
    lm = lm.replace(esc, '\\$0');

    // Now, iterate over the captured snapshot
    for (var i = 1; i <= 9; i++) {
        var m = cap['$'+i];

        // If it's empty, add an empty capturing group
        if (!m)
            lm = '()' + lm;

        // Else find the escaped string in lm wrap it to capture it
        else
            lm = lm.replace(m.replace(esc, '\\$0'), '($0)');

        // Push to `reg` and chop `lm`
        reg.push(lm.slice(0, lm.indexOf('(') + 1));
        lm = lm.slice(lm.indexOf('(') + 1);
    }

    // Create the property-reconstructing regular expression
    ret.exp = RegExp(reg.join('') + lm, RegExp.multiline ? 'm' : '');

    return ret;
}

It does what I originally thought to be difficult. This should restore all the properties to their former values, if you use it like so:

var 
    // Create a 'restore point' for RegExp
    old  = createRegExpRestore(),

    // Run your own regular expression
    test = someOtherRegEx.test(someValue);

// Restore the previous values by running the RegExp
old.exp.test(old.input);

Collectives™ on Stack Overflow

Prevent tainting properties of the RegExp constructor in JavaScript

2 Answers 2

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related