删除字符串中第二次出现的正则表达式

Question

I'm trying to write a JavaScript function that removes any second occurrence of a character using the regular expression. Here is my function

var removeSecondOccurrence = function(string) {
return string.replace(/(.*)\1/gi, '');
}

It's only removing consecutive occurrence. I'd like it to remove even non consecutive one. for example papirana should become pairn.

Please help

Answer 1

A non-regexp solution:

 "papirana".split("").filter(function(x, n, self) { return self.indexOf(x) == n }).join("")

Regexp code is complicated, because JS doesn't support lookbehinds:

str = "papirana";
re = /(.)(.*?)\1/;
while(str.match(re)) str = str.replace(re, "$1$2")

or a variation of the first method:

"papirana".replace(/./g, function(a, n, str) { return str.indexOf(a) == n ? a : "" })

Answer 2

Using a zero-width lookahead assertion you can do something similar

"papirana".replace(/(.)(?=.*\1)/g, "")

returns

"pirna"

The letters are of course the same, just in a different order.

Passing the reverse of the string and using the reverse of the result you can get what you're asking for.

Answer 3

This is how you would do it with a loop:

var removeSecondOccurrence = function(string) {
    var results = "";
    for (var i = 0; i < string.length; i++)
        if (!results.contains(string.charAt(i)))
            results += string.charAt(i);
}

Basically: for each character in the input, if you haven't seen that character already, add it to the results. Clear and readable, at least.

Answer 4

What Michelle said.

In fact, I strongly suspect it cannot be done using regular expressions. Or rather, you can if you reverse the string, remove all but the first occurences, then reverse again, but it's a dirty trick and what Michelle suggests is way better (and probably faster).

If you're still hot on regular expressions...

"papirana".
    split("").
    reverse().
    join("").
    replace(/(.)(?=.*\1)/g, '').
    split("").
    reverse().
    join("")

// => "pairn"

The reason why you can't find all but the first occurence without all the flippage is twofold:

• JavaScript does not have lookbehinds, only lookaheads
• Even if it did, I don't think any regexp flavour allows variable-length lookbehinds