Question

我必须在JavaScript中创建一个删除字符串中所有重复字母的函数。到目前为止，我已经能够做到这一点：如果我有“anaconda”这个词，它会显示我作为结果“anaconda”，它应该显示“鳕鱼”。这是我的代码：

function find_unique_characters( string ){
    var unique='';
    for(var i=0; i<string.length; i++){
        if(unique.indexOf(string[i])==-1){
            unique += string[i];
        }
    }
    return unique;
}
console.log(find_unique_characters('baraban'));

Answer 1

我们现在也可以使用过滤方法清理：

function removeDuplicateCharacters(string) {
  return string
    .split('')
    .filter(function(item, pos, self) {
      return self.indexOf(item) == pos;
    })
    .join('');
}
console.log(removeDuplicateCharacters('baraban'));

工作示例： https://jsfiddle.net/masterspambot/ppz6uec1/

Answer 2

function find_unique_characters(str) {
  var unique = '';
  for (var i = 0; i < str.length; i++) {
    if (str.lastIndexOf(str[i]) == str.indexOf(str[i])) {
      unique += str[i];
    }
  }
  return unique;
}

console.log(find_unique_characters('baraban'));
console.log(find_unique_characters('anaconda'));

如果您只想返回在字符串中出现一次的字符，请检查它们的最后一次出现是否与第一次出现的位置相同。

您的代码至少返回字符串中的所有字符一次，而不是只返回不超过一次的字符。 _{但显然你已经知道了，否则就不会有问题了; - ）}

Answer 3

只是想添加我的解决方案以获得乐趣：

function removeDoubles(string) {
  var mapping = {};
  var newString = '';

  for (var i = 0; i < string.length; i++) {
    if (!(string[i] in mapping)) {
      newString += string[i];
      mapping[string[i]] = true;
    }
  }
  return newString;
}

Answer 4

  //One simple way to remove redundecy of Char in String
       var char = "aaavsvvssff"; //Input string
       var rst=char.charAt(0);
       for(var i=1;i<char.length;i++){              
           var isExist = rst.search(char.charAt(i));
            isExist >=0 ?0:(rst +=  char.charAt(i) ); 
       }
       console.log(JSON.stringify(rst)); //output string : avsf

Answer 5

对于字符串（一行）

removeDuplicatesStr = str => [...new Set(str)].join('');

对于数组（一行）

removeDuplicatesArr = arr => [...new Set(arr)]

Answer 6

DEMO

function find_unique_characters( string ){
    unique=[];
    while(string.length>0){
        var char = string.charAt(0);
        var re = new RegExp(char,"g");
        if (string.match(re).length===1) unique.push(char);
        string=string.replace(re,"");
    }        
    return unique.join("");
}
console.log(find_unique_characters('baraban')); // rn
console.log(find_unique_characters('anaconda')); //cod

Answer 7

如果您希望函数仅在参数中返回一组唯一的字符，那么这段代码可能会派上用场。在这里，您还可以检查记录在标题为“ nonUnique”的数组中的非唯一值：

function remDups(str){
    if(!str.length)
        return '';
    var obj = {};
    var unique = [];
    var notUnique = [];
    for(var i = 0; i < str.length; i++){
        obj[str[i]] = (obj[str[i]] || 0) + 1;
    }
    Object.keys(obj).filter(function(el,ind){
        if(obj[el] === 1){
            unique+=el;
        }
        else if(obj[el] > 1){
            notUnique+=el;
        }
    });
return unique;
}
console.log(remDups('anaconda')); //prints 'cod'

如果要在传递的字符串中返回仅出现一次的字符集，可以使用以下代码：

function remDups(str){
    if(!str.length)
        return '';
    var s = str.split('');
    var obj = {};
    for(var i = 0; i < s.length; i++){
        obj[s[i]] = (obj[s[i]] || 0) + 1;
    }
    return Object.keys(obj).join('');
}
console.log(remDups('anaconda')); //prints 'ancod'

Answer 8

使用lodash：

_.uniq('baraban').join(''); // returns 'barn'

Answer 9

您可以像这样将字符作为要删除的参数作为参数

function find_unique_characters(str, char){
  return [...new Set(str.split(char))].join(char);
}

function find_unique_characters(str, char){
  return [...new Set(str.split(char))].join(char);
}

let result = find_unique_characters("aaaha ok yet?", "a");
console.log(result);

Answer 10

使用设置：

function removeDuplicates(str){
  return [...new Set(str.split(''))].join('');
}

Answer 11

试试这段代码，它有效：）

var str="anaconda";
Array.prototype.map.call(str, 
 (obj,i)=>{
  if(str.indexOf(obj,i+1)==-1 && str.lastIndexOf(obj,i-1)==-1){
   return obj;
  }
 }
).join("");
//output: "cod"

Answer 12

function removeduplicate(str) {

let map = new Map();
// n 
for (let i = 0; i < str.length; i++) {
    if (map.has(str[i])) {
        map.set(str[i], map.get(str[i]) + 1);
    } else {
        map.set(str[i], 1);
    }

}


let res = '';

for (let i = 0; i < str.length; i++) {
    if (map.get(str[i]) === 1) {
        res += str[i];
    }
}

// o (2n) - > O(n)

// space o(n)

return res;

}

Answer 13

    function removeDuplicates(str) {
       var result = "";
       var freq = {};
       for(i=0;i<str.length;i++){
        let char = str[i];
        if(freq[char]) {
          freq[char]++;     
        } else {
           freq[char] =1
           result +=char;
       }
    }
  return result;
}

Answer 14

使用Set()并进行两次销毁会更短：

const str = 'aaaaaaaabbbbbbbbbbbbbcdeeeeefggggg';

const unique = [...new Set([...str])].join('');

console.log(unique);

Answer 15

console.log(("anaconda").split('').sort().join('').replace(/(.)\1+/g, ""));

通过此操作，您可以在一行中完成。

输出：'cdo'

Answer 16

   function removeDuplicates(string){
      return string.split('').filter((item, pos, self)=> self.indexOf(item) == pos).join('');
   }

过滤器将删除使用当前元素的项目索引和位置之前看到的所有字符

Answer 17

是的，我们可以不使用JavaScript函数来实现这一点：

var name = 'sssssddddddddddfffffff';

let i = 0;
let newarry = [];

for (let singlestr of name) {
    newarry[i] = singlestr;
    i++;
}


// now we have new Array and length of string
length = i;

function getLocation(recArray, item, arrayLength) {

    firstLaction = -1;
    for (let i = 0; i < arrayLength; i++) {

        if (recArray[i] === item) {
            firstLaction = i;
            break;
        }

    }

    return firstLaction;

}


let finalString = '';
for (let b = 0; b < length; b++) {

    const result = getLocation(newarry, newarry[b], length);
    if (result === b) {
        finalString += newarry[b];
    }

}
console.log(finalString); // sdf

Answer 18

// Try this way 

const str = 'anaconda';
const printUniqueChar = str => {
   const strArr = str.split("");
   const uniqueArray = strArr.filter(el => {
      return strArr.indexOf(el) === strArr.lastIndexOf(el);
   });
   return uniqueArray.join("");
};
console.log(printUniqueChar(str)); // output-> cod

Answer 19

我有3个无环，单线方法。

方法1 - 删除重复项，并保留原始字符顺序：

var str = "anaconda";
var newstr = str.replace(new RegExp("[^"+str.split("").sort().join("").replace(/(.)\1+/g, "").replace(/[.?*+^$[\]\\(){}|-]/g, "\\$&")+"]","g"),"");
//cod

方法2 - 删除重复但不保留字符顺序，但可能比方法1更快，因为它使用较少的正则表达式：

var str = "anaconda";
var newstr = str.split("").sort().join("").replace(/(.)\1+/g, "");
//cdo

方法3 - 删除重复项，但保留唯一值（也不保留字符顺序）：

var str = "anaconda";
var newstr = str.split("").sort().join("").replace(/(.)(?=.*\1)/g, "");
//acdno

Answer 20

var str = 'anaconda'.split('');
var rmDup = str.filter(function(val, i, str){
     return str.lastIndexOf(val) === str.indexOf(val);
});
console.log(rmDup); //prints ["c", "o", "d"]

请在此处验证：https://jsfiddle.net/jmgy8eg9/1/

Answer 21

这应该可以使用正则表达式;
注意：实际上，我不知道这个正则表达式如何工作，但我知道它的简写＆＃39; ，所以，我会更好地向你解释这个/(.+)(?=.*?\1)/g;的含义。这个正则表达式只返回给我一个数组中的重复字符，所以我循环通过它来获得重复字符的长度。但这不适用于像"#" "_" "-",这样的特殊字符，但是它会给你预期的结果;包括那些特殊字符if any

function removeDuplicates(str){
    var REPEATED_CHARS_REGEX = /(.+)(?=.*?\1)/g;
    var  res = str.match(REPEATED_CHARS_REGEX);
    var word = res.slice(0,1);
    var raw = res.slice(1);
    var together = new String (word+raw);
    var fer = together.toString();
    var length = fer.length;
    // my sorted duplicate;
      var result = '';
      for(var i = 0; i < str.length; i++) {
        if(result.indexOf(str[i]) < 0) {
          result += str[i];
        }
      }

      return {uniques: result,duplicates: length};
    } removeDuplicates('anaconda')

正则表达式/([a-zA-Z])\1+$/正在寻找：

([a-zA-Z]]) - 它在第一组中捕获的一封信;然后 \1+ - 紧随其后一封或多份该信;然后 $ - 字符串的结尾。将其更改为/([a-zA-Z]).*?\1/而不是搜索：

([a-zA-Z]) - 它在第一组中捕获的一封信;然后 .*? - 零个或多个字符（？表示尽可能少）;直到 \1 - 它找到第一个匹配字符的重复。

Answer 22

刚刚遇到类似问题（找到重复项）。基本上，使用哈希来跟踪字符出现次数，并使用＆＃34;一次性命中奇迹构建一个新字符串＆＃34;：

def mask(df):
        df.loc[df.index.get_level_values('dis').between(0.8,1.0), 'Price1'].mean()
        df.loc[df.index.get_level_values('dis').between(1.0,2.6), 'Price1'].mean()
         return df

print (df_new.ix[:,'Price1']).apply(mask)

<强>用法：

function oneHitWonders(input) {
    var a = input.split('');
    var l = a.length;
    var i = 0;
    var h = {};
    var r = "";

    while (i < l) {
        h[a[i]] = (h[a[i]] || 0) + 1;

        i += 1;
    }

    for (var c in h) {
        if (h[c] === 1) {
            r += c;
        }
    }

    return r;
}

Answer 23

这是我用过的东西 - 还没有对空格或特殊字符进行测试，但是对于纯字符串应该可以正常工作：

function uniquereduce(instring){ 
    outstring = ''
    instringarray = instring.split('')
    used = {}
    for (var i = 0; i < instringarray.length; i++) {
        if(!used[instringarray[i]]){
            used[instringarray[i]] = true
            outstring += instringarray[i]
        }
    }
    return outstring
}

Answer 24

此代码对我有用，可以从字符串中删除重复（重复）字符（即使其单词以空格分隔）

链接：Working Sample JSFiddle

/* This assumes you have trim the string and checked if it empty */
function RemoveDuplicateChars(str) {
   var curr_index = 0;
   var curr_char;
   var strSplit;
   var found_first;
   while (curr_char != '') {
      curr_char = str.charAt(curr_index);
      /* Ignore spaces */
      if (curr_char == ' ') {
         curr_index++;
         continue;
      }
      strSplit = str.split('');
      found_first = false;
      for (var i=0;i<strSplit.length;i++) {
         if(str.charAt(i) == curr_char && !found_first) 
            found_first = true;
         else if (str.charAt(i) == curr_char && found_first) {
            /* Remove it from the string */
            str = setCharAt(str,i,'');
         }
      }
      curr_index++;
   }
   return str;
}
function setCharAt(str,index,chr) {
    if(index > str.length-1) return str;
    return str.substr(0,index) + chr + str.substr(index+1);
}

Answer 25

function removeDup(str) {
  var arOut = [];
  for (var i=0; i < str.length; i++) {
    var c = str.charAt(i);
    if (c === '_') continue;
    if (str.indexOf(c, i+1) === -1) {
      arOut.push(c);
    }
    else {
      var rx = new RegExp(c, "g");
      str = str.replace(rx, '_');
    }
  }
  return arOut.join('');
}

Answer 26

另一种删除所有出现不止一次的字母的方法：

function find_unique_characters( string ) {
    var mapping = {};
    for(var i = 0; i < string.length; i++) {
        var letter = string[i].toString();
        mapping[letter] = mapping[letter] + 1 || 1;
    }
    var unique = '';
    for (var letter in mapping) {
        if (mapping[letter] === 1)
            unique += letter;
    }

    return unique;
}

Live test case

说明：遍历字符串中的所有字符，将每个字符映射到字符串中出现的次数。然后迭代项目（字符串中出现的字母）并仅选择仅出现一次的项目。

Answer 27

我有FF / Chrome，其工作正常：

var h={}; 
"anaconda".split("").
  map(function(c){h[c] |= 0; h[c]++; return c}).
  filter(function(c){return h[c] == 1}).
  join("")

如果您编写如下函数，则可以重复使用：

function nonRepeaters(s) {
  var h={}; 
  return s.split("").
    map(function(c){h[c] |= 0; h[c]++; return c}).
    filter(function(c){return h[c] == 1}).
    join("");
 }

对于缺少map，filter等的旧浏览器，我猜测它可以通过jQuery或原型模拟...

Answer 28

我们可以使用[49, 151, ...]循环删除字符串中的重复或类似元素，并提取for，slice，substring

等字符串方法

示例，如果您要删除重复的元素，例如substr：

aababbafabbb

如果您想了解更多信息，请与我们联系。

Answer 29

    function RemDuplchar(str)
{
    var index={},uniq='',i=0;
    while(i<str.length)
    {
        if (!index[str[i]])
        {
         index[str[i]]=true;
         uniq=uniq+str[i];
        }
            i++;
    }
    return uniq;
}

从字符串中删除重复字符

29 个答案: