Supprimer les occurrences de mots en double dans une chaîne

Prendre la chaîne suivante à titre d'exemple:

var string = "spanner, span, spaniel, span";

De cette chaîne je voudrais trouver le double de mots, de supprimer tous les doublons d'en garder une occurrence du mot, puis en sortie de la version révisée de la chaîne.

Qui, dans cet exemple serait:

var string = "spanner, span, spaniel";

J'ai configuré un jsFiddle pour les essais de: http://jsfiddle.net/p2Gqc/

Noter que l'ordre des mots dans la chaîne n'est pas uniforme, ni de la longueur de chaque corde pour une regex ne va pas faire le travail ici, je ne pense pas. Je pense à quelque chose le long des lignes de découpage de la chaîne dans un tableau? Mais j'aimerais qu'il soit comme la lumière sur le client que possible et super rapide...

source d'informationauteur CLiown

Comment quelque chose comme cela?

fractionner la chaîne, obtenir le tableau, de le filtrer pour retirer les doublons, de se joindre à eux en arrière.

var uniqueList=string.split(',').filter(function(item,i,allItems){
    return i==allItems.indexOf(item);
}).join(',');

$('#output').append(uniqueList);

Violon

Pour les non porteurs des navigateurs, vous pouvez y remédier en ajoutant ceci dans votre js.

Voir Filtre

if (!Array.prototype.filter)
{
  Array.prototype.filter = function(fun /*, thisp*/)
  {
    "use strict";

    if (this == null)
      throw new TypeError();

    var t = Object(this);
    var len = t.length >>> 0;
    if (typeof fun != "function")
      throw new TypeError();

    var res = [];
    var thisp = arguments[1];
    for (var i = 0; i < len; i++)
    {
      if (i in t)
      {
        var val = t[i]; //in case fun mutates this
        if (fun.call(thisp, val, i, t))
          res.push(val);
      }
    }

    return res;
  };
}

Si non des travaux ci-dessus pour vous voici une autre façon:

var str = "spanner, span, spaniel, span";
str = str.replace(/[ ]/g,"").split(",");
var result = [];
for(var i =0; i < str.length ; i++){
    if(result.indexOf(str[i]) == -1) result.push(str[i]);
}
result=result.join(", ");

Ou si vous souhaitez qu'il soit dans une meilleure forme, essayez ceci:

Array.prototype.removeDuplicate = function(){
   var result = [];
   for(var i =0; i < this.length ; i++){
       if(result.indexOf(this[i]) == -1) result.push(this[i]);
   }
   return result;
}
var str = "spanner, span, spaniel, span";
str = str.replace(/[ ]/g,"").split(",").removeDuplicate().join(", ");

1

Les deux autres réponses serait bien fonctionner, bien que la filter tableau de la méthode utilisée par le PSL a été ajouté dans ECMAScript 5 et ne sera pas disponible dans les anciens navigateurs.

Si vous êtes à la manipulation des chaînes longues, puis en utilisant $.inArray/Array.indexOf n'est pas le moyen le plus efficace de vérifier si vous avez vu un article avant (cela impliquerait que la numérisation de l'ensemble du tableau à chaque fois). Au lieu de cela, vous pouvez stocker chaque mot clé dans un objet et de profiter de hachage basée sur look-ups qui sera beaucoup plus rapide que la lecture par le biais d'un grand tableau.
```
var tmp={};
var arrOut=[];
$.each(string.split(', '), function(_,word){
    if (!(word in tmp)){
        tmp[word]=1;
        arrOut.push(word);
    }
});
arrOut.join(', ');
```
1
```
<script type="text/javascript">
str=prompt("Enter String::","");
arr=new Array();
arr=str.split(",");
unique=new Array();
for(i=0;i<arr.length;i++)
{
    if((i==arr.indexOf(arr[i]))||(arr.indexOf(arr[i])==arr.lastIndexOf(arr[i])))
        unique.push(arr[i]);   
}
unique.join(",");
alert(unique);
</script>
```
ce bloc de code permettra de supprimer les doublons de mots d'une phrase.

la première condition de l'instruction si je.e (i==arr.indexOf(arr[i])) comprendra la première occurence d'une répétition de mot pour le résultat(variale unique dans ce code).

la deuxième condition (arr.indexOf(arr[i])==arr.lastIndexOf(arr[i])) comprendra tous les non répétition des mots.

//Take the following string
var string = "spanner, span, spaniel, span";
var arr = string.split(", ");
var unique = [];
$.each(arr, function (index,word) {
    if ($.inArray(word, unique) === -1) 
        unique.push(word);

});

alert(unique);

DÉMO

ci-dessous est un outil facile à comprendre et rapide code pour supprimer les doublons de mots dans une chaîne de caractères:

var string = "spanner, span, spaniel, span";


var uniqueListIndex=string.split(',').filter(function(currentItem,i,allItems){
    return (i == allItems.indexOf(currentItem));
});

var uniqueList=uniqueListIndex.join(',');

alert(uniqueList);//Result:spanner, span, spaniel

Aussi simple que cela peut résoudre votre problème. Espérons que cette aide. Cheers 🙂

Pour supprimer tous les doublons mots, j'utilise ce code:

<script>
function deleteDuplicate(a){a=a.toString().replace(//g,",");a=a.replace(/[ ]/g,"").split(",");for(var b=[],c=0;c<a.length;c++)-1==b.indexOf(a[c])&&b.push(a[c]);b=b.join(", ");return b=b.replace(/,/g," ")};
document.write(deleteDuplicate("g g g g"));
</script>

-1
```
var string = "spanner, span, spaniel, span";

var strArray= string.split(",");

var unique = [];
 for(var i =0; i< strArray.length; i++)
 {
   eval(unique[strArray] = new Object()); 
 }
```
//Vous pouvez facilement traverser l'unique à travers foreach.

J'aime ce pour trois raison.
Tout d'abord, il fonctionne avec IE8 ou n'importe quel autre navigateur.

Seconde. il est plus optimisée et la garantie d'avoir de résultat unique.

Dernier, Il travaille pour un Autre tableau de Chaîne qui a un espace Blanc dans leurs intrants, comme la
```
var string[] = {"New York", "New Jersey", "South Hampsire","New York"};
```
pour le cas ci-dessus il n'y aura qu' trois éléments dans le string[] qui serait parfaitement conservés.

Vous devez vous connecter pour publier un commentaire.