Don't replace regex if it is enclosed by a character

Question

I would like to replace all strings that are enclosed by - into strings enclosed by ~ , but not if this string again is enclosed by * .

As an example, this string...

The -quick- *brown -f-ox* jumps.

...should become...

The ~quick~ *brown -f-ox* jumps.

We see - is only replaced if it is not within *<here>* .

My javascript-regex for now (which takes no care whether it is enclosed by * or not):

var message = source.replace(/-(.[^-]+?)-/g, "~$1~");

Edit: Note that it might be the case that there is an odd number of * s.

Answer 1

That's a tricky sort of thing to do with regular expressions. I think what I'd do is something like this:

var msg = source.replace(/(-[^-]+-|\*[^*]+\*)/g, function(_, grp) {
  return grp[0] === '-' ? grp.replace(/^-(.*)-$/, "~$1~") : grp;
});

jsFiddle Demo

That looks for either - or * groups, and only performs the replacement on dashed ones. In general, "nesting" syntaxes are challenging (or impossible) with regular expressions. (And of course as a comment on the question notes, there are special cases — dangling metacharacters — that complicate this too.)

Answer 2

I would solve it by splitting the array based on * and then replacing only the even indices. Matching unbalanced stars is trickier, it involves knowing whether the last item index is odd or even:

'The -quick- *brown -f-ox* jumps.'
    .split('*')
    .map(function(item, index, arr) { 
        if (index % 2) {
            if (index < arr.length - 1) {
                return item; // balanced
            }
            // not balanced
            item = '*' + item;
        }
        return item.replace(/\-([^-]+)\-/, '~$1~');
    })
    .join('');

Demo

Answer 3

Finding out whether a match is not enclosed by some delimiters is a very complicated task - see also this example . Lookaround could help, but JS only supports lookahead. So we could rewrite " not surrounded by ~ " to " followed by an even number or ~ ", and match on that:

source.replace(/-([^-]+)-(?=[^~]*([^~]*~[^~]*~)*$)/g, "~$1~");

But better we match on both - and * , so that we consume anything wrapped in * s as well and can then decide in a callback function not to replace it:

source.replace(/-([^-]+)-|\*([^*]+)\*/g, function(m, hyp) {
    if (hyp) // the first group has matched
        return "~"+hyp+"~";
    // else let the match be unchanged:
    return m;
});

This has the advantage of being able to better specify " enclosed ", eg by adding word boundaries on the "inside", for better handling of invalid patterns (odd number of * characters as mentioned by @Maras for example) - the current regex just takes the next two appearances.

Answer 4

A terser version of Jack's very clear answer.

source.split(/(\*[^*]*\*)/g).map(function(x,i){
return i%2?x:x.replace(/-/g,'~');
}).join('');

Seems to work, Cheers.