JavaScript方法从字符串/数字中删除不区分大小写的重复项

Question

Looking for a clean way to remove duplicates and keep with the first occurrence of the duplicate number/letter found

Let's say I have a string

AbCyTtaCc113

What I want remaining is

AbCyT13

Answer 1

  [...input].filter((s => c => !s.has(c.toLowerCase()) && s.add(c.toLowerCase()))(new Set)).join("")

Spreading a string results in an array with one character strings, by using a Set you can easily filter out duplicates. The logic is basically:

• Turn the string into an array of characters by spreading it ( [...input] ).

• Create a Set and store it inside of the closure as s . ( (s => ...)(new Set) )

• Filter out the characters if

  • the character is in the Set already ( !s.has(c.toLowerCase())

  • if it is not, add it to the Set and keep it ( && s.add(c.toLowerCase()) )

• Turn the filtered array back into a string by joining it.

Or the case insensitive version:

[...new Set(input)].join("")

---

The imperative version would be:

  let result = "";
  {
     const duplicates = new Set();
     for(const char of input) {
        if(!duplicates.has(char.toLowerCase()) {
          duplicates.add(char.toLowerCase());
          result += char;
        }
     }
  }

Answer 2

this doesn't need ES6, it does not make it faster, nor cleaner for this case. Walk it once and reduce:

"AbCyTtaCc113"
.split("")
.reduce((ac,d)=>{!~ac.toLowerCase().indexOf(d.toLowerCase()) && (ac += d); return ac;},"")

Answer 3

Using Array.prototype.reduce would be one way to address this.

Edit: As others have mentioned, there's valid reasons though not to use this for production level solutions. So just take it as one possible , though not advisable way.

 console.log( [..."AbCyTtaCc113"] .reduce( (acc, val) => acc.includes(val.toUpperCase()) || acc.includes(val.toLowerCase()) ? acc : [...acc, val] , [] ) .join("") ) 

Answer 4

I believe @ggorlen has the appropriate solution, although he uses some rather modern JavaScript (I haven't seen a syntax before using back-ticks instead of parenthesis to call functions, but I'll trust it works in some interpreters)

For a simpler "old-school" answer, try something like the following:

var input = "AbCyTtaCc113";
var output = "";
var unique = {};
for (var i = 0; i < input.length; i++) {
    if (!unique[input[i].toLowerCase()]) {
        unique[input[i].toLowerCase()] = 1;
        output += input[i];
    }
}

Second update

The ES6 solution below was preserved for historical purposes, but @ggorlen pointed out that I failed to preserve casing on the output. Therefore the conversion to lowercase should only occur within the filter check and not prior:

var input = "AbCyTtaCc113";
var seen = new Set();
var output = input
    .split("")
    .filter(x => !seen.has(x.toLowerCase()) && seen.add(x.toLowerCase()))
    .join("")

Update

Since everyone is having fun writing ES6 answers and trying to solve this with reduce or map or Set or some other such tool, let me write what I think is the best answer using ES6:

var input = "AbCyTtaCc113";
var seen = new Set();
var output = input
    .split("")
    .map(x => x.toLowerCase())
    .filter(x => !seen.has(x) && seen.add(x))
    .join("")

Or, if you prefer unreadable one-line nonsense:

var input = "AbCyTtaCc113";

var seen = new Set(), output = input.split("").map(x => x.toLowerCase()).filter(x => !seen.has(x) && seen.add(x)).join("");

I prefer this solution because:

1. It utilizes method chaining to pass our input through a series of simple transforms which can be easily read and interpreted by future programmers (first split, then map, then filter, then join)
2. It avoids syntax that isn't supported in many JavaScript interpreters (no spread operators, back-ticks, etc)
3. It uses each method for its semantic purpose (split converts a string to an array, map modifies each value of an array, filter selects a subset of an array, join converts an array to a string)

That said, if performance is your primary concern and you're running this in the Google Chrome console, I must admit that preliminary benchmarks peg Jonas Wilm's answer as faster than mine:

var d0 = new Date(); for (var i = 0; i < 50000; i++) {
    var input = "AbCyTtaCc113";
    var output = [...input].filter((s => c => !s.has(c.toLowerCase()) && s.add(c.toLowerCase()))(new Set)).join("");
} console.log(new Date() - d0);
// ~175

var d0 = new Date(); for (var i = 0; i < 50000; i++) {
    var input = "AbCyTtaCc113";
    var seen = new Set();
    var output = input
        .split("")
        .map(x => x.toLowerCase())
        .filter(x => !seen.has(x) && seen.add(x))
        .join("");
} console.log(new Date() - d0);
// ~231

I believe this is because .map() is allocating a new array in memory rather than modifying the array in-place (whereas his solution utilizing .toLowerCase() within .has() modifies the values in place so uses no extra memory), but I prefer this for clarity. Unless you're dealing with code where performance is of the utmost importance, I think being able to read the code is more important than eeking out an extra millisecond.