Well, you can use this:

var reg = new RegExp(oldWord, "g");
myString.replace(reg, "");

or simply:

myString.replace(new RegExp(oldWord, "g"), "");

A simple solution is not to use RegEx at all. Use Template literals

var module = 'm1',
    taskId = 't1',
    hash   = 'h1';

var url = `/task/${module}?taskId=${taskId}#${hash}`;

var module = 'm1',
    taskId = 't1',
    hash = 'h1';

var url = `/task/${module}?taskId=${taskId}#${hash}`;

document.body.innerHTML = url;

Using RegEx:

function replaceUrl(url, data) {
    // Create regex using the keys of the replacement object.
    var regex = new RegExp(':(' + Object.keys(data).join('|') + ')', 'g');

    // Replace the string by the value in object
    return url.replace(regex, (m, $1) => data[$1] || m);
}

function replaceUrl(url, data) {
    var regex = new RegExp(':(' + Object.keys(data).join('|') + ')', 'g');

    return url.replace(regex, (m, $1) => data[$1] || m);
}


var updatedUrl = replaceUrl('/task/:module?taskId=:taskId#:hash', {
    module: 'm1',
    taskId: 't1',
    hash: 'h1'
});

console.log(updatedUrl);
document.body.innerHTML = updatedUrl;

Instead of using the /\sREGEX\s/g syntax, you can construct a new RegExp object:

// variable == 'REGEX'
let re = new RegExp(String.raw`\s${variable}\s`, "g");

You can dynamically create regex objects this way. Then you will do:

"mystring1".replace(re, "newstring");

For older browser or node

// variable == 'REGEX'
var re = new RegExp("\\s" + variable + "\\s", "g");
"mystring1".replace(re, "newstring");

The biggest issue, I think, is that you are not just running a regex, but also running a replace over the entire HTML multiple times. And you are setting the actual DOM HTML multiple times rather than manipulating a string until you get the result, and then setting the HTML once. I would strongly recommend using a library like Handlebars.js, but if you want to do it yourself, a very quick implementation would be something like:

var translations = { 
    heading: { 
        hello: "hello" 
    }, 
    txt: { 
        welcome: "welcome" 
    }, 
    image: { 
        description: "this is a test" 
    }
};

function get(obj, desc) {
    var arr = desc.split(".");
    while(arr.length && (obj = obj[arr.shift()]));
    return obj;
}

function replaceTokens(HTML) {
    return HTML.split('{{').map(function(i) { 
        var symbol = i.substring(0, i.indexOf('}}')).trim(); 
        return i.replace(symbol + '}}', get(translations, symbol)); 
    }).join('');
}

Well if you are returning this function as a string, just use String#replace() method to replace x occurrence with its value.

This is how you should use it:

funcString.replace('x', x)

Demo:

let x = Math.random();

let funcString = function () {
    let y = x + 10;
    return y;
}.toString();

console.log(funcString.replace('x', x));

Edit:

If your variable has many occurrences and can be part of other variables just use a regex with replace method.

funcString.replace(/\bx\b/g, x)

Demo:

let x = Math.random();

let funcString = function () {
    let y = x + 10;
    let fix ='true';
    let z = x * 2;
    return y;
}.toString();

console.log(funcString.replace(/\bx\b/g, x));

Your current regex extracts all the text contained within {{}} with its capture group. But you only want the index of the replacement, which is contained within the [], and not the entire string itself. So you have two options:

• Modify regex to capture only the index, so that would look like /{{field\[(.+?)\]}}/, where the capture group now only takes the number within the brackets.
• Leave the original regex alone, but change the replace function to extract the number from the returned match. In this case you'll have a second regex (or some other method) to extract the number from the matched string (in this case, get "10" out of "field[10]").

Here's an example demonstrating both:

var string = 'This is some content: {{field[10]}}';
var submission = {inputs: []};
submission.inputs[10] = 'replace value';

// I want the new string to be this
// var newString = 'This is some content: replace value';

var newString = string.replace(/{{field\[(.+?)\]}}/g, (match, cap1) => submission.inputs[cap1]);
console.log(newString)

// OR:

var otherNewString = string.replace(/\{{(.+?)}}/g, (match, cap1) => submission.inputs[cap1.match(/\[(.+?)\]/)[1]]);
console.log(otherNewString)

First, the replace function returns a string, it does not mutate the variable. So, proper usage is as follows:

source = source.replace('old', 'new');

You should take care to ensure that your input is in the exact format, because if there is no trailing comma after the last value, and you want to replace the last value, then simply using replace would fail.

This seems to work without needing look-behinds or look-aheads:

let regExMonth = /\bmonths\b/gm;
let str = "months + 3 + (startmonths * 3) + months - (months*7) + (monthsend*5)";

str = str.replace(regExMonth, "12");
console.log(str);

Screenshot from regexr.com:

You're right that the look-behinds don't work everywhere yet. However, they do work in Chrome, and they'll be working in Firefox soon. Look-behinds were added in the 2018 specification, so it is shameful that they are not yet ubiquitous here in 2020.

Where look-behinds are supported, I'd use a both a "negative look-behind" and a "negative look-ahead" too like this:

(?<![A-Za-z0-9_])(months)(?![A-Za-z0-9_])

Shorthand of above would be:

(?<![\w])(months)(?![\w])

Screenshot from regexr.com: