converting RegExp to String then back to RegExp

Question

So I have a RegExp regex = /asd/

I am storing it as a as a key in my key-val store system.

So I say str = String(regex) which retur

Answer 1

If you don't need to store the modifiers, you can use Regexp#source to get the string value, and then convert back using the RegExp constructor.

var regex = /abc/g;
var str = regex.source; // "abc"
var restoreRegex = new RegExp(str, "g");

---

If you do need to store the modifiers, use a regex to parse the regex:

var regex = /abc/g;
var str = regex.toString(); // "/abc/g"
var parts = /\/(.*)\/(.*)/.exec(str);
var restoredRegex = new RegExp(parts[1], parts[2]);

This will work even if the pattern has a / in it, because .* is greedy, and will advance to the last / in the string.

If performance is a concern, use normal string manipulation using String#lastIndexOf:

var regex = /abc/g;
var str = regex.toString(); // "/abc/g"
var lastSlash = str.lastIndexOf("/");
var restoredRegex = new RegExp(str.slice(1, lastSlash), str.slice(lastSlash + 1));

Answer 2

const regex = /asd/gi;

converting RegExp to String

const obj = {flags: regex.flags, source: regex.source};
const string = JSON.stringify(obj);

then back to RegExp

const obj2 = JSON.parse(string);
const regex2 = new RegExp(obj2.source, obj2.flags);

Requires ES6+.

Answer 3

let rx = RegExp.apply(RegExp, str.match(/\/(.*)\/(.*)/).slice(1));

A modified version of @PegasusEpsilon answer

Answer 4

You can use the following before storage of your regex literal:

(new RegExp(regex)).source

See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/source

Example:

regex = /asd/

string = (new RegExp(regex)).source
// string is now "asd"

regex = RegExp(string)
// regex has the original value /asd/

Answer 5

StackOverflow saves the day again, thanks @4castle! I wanted to store some regex rules in a JS file, and some in a DB, combine them into an array of objects like so:

module.exports = {
    [SETTINGS.PRODUCTION_ENV]: [

        {
            "key": /<meta name="generator"[\s\S]*?>/gmi,
            "value": "",
            "regex": true
        },

        ...
    ]
}

Then, loop through each environment's objects and apply it to a string of text. This is for a node/lambda project, so I wanted to use ES6. I used @4castle's code, with some destructuring, and I ended up with this:

    let content = body;
    const regexString = replacement.key.toString();
    const regexParts = /\/(.*)\/(.*)/.exec(regexString);
    const {1: source, 2: flags} = regexParts;
    const regex = new RegExp(source, flags);
    content = content.replace(regex, replacement.value);
    
    return content;

Works a treat!