it-swarm-eu.dev

Comment remplacer toutes les occurrences d'une chaîne en JavaScript

J'ai cette ficelle:

"Test abc test test abc test test test abc test test abc"

Faire

str = str.replace('abc', '');

semble ne supprimer que la première occurrence de abc dans la chaîne ci-dessus. Comment puis-je remplacer toutes occurrences?

3564
Click Upvote

Par souci d'exhaustivité, j'ai réfléchi à la méthode que je devrais utiliser pour le faire. Il existe essentiellement deux façons de procéder, comme le suggèrent les autres réponses de cette page.

Remarque: En général, il n'est pas recommandé d'étendre les prototypes intégrés en JavaScript. Je fournis des extensions sur le prototype String simplement à des fins d'illustration, illustrant différentes implémentations d'une méthode standard hypothétique sur le prototype intégré String.


Implémentation basée sur une expression régulière

String.prototype.replaceAll = function(search, replacement) {
    var target = this;
    return target.replace(new RegExp(search, 'g'), replacement);
};

Mise en œuvre fractionnée et jointe (fonctionnelle)

String.prototype.replaceAll = function(search, replacement) {
    var target = this;
    return target.split(search).join(replacement);
};

Ne sachant pas trop comment les expressions régulières fonctionnent en coulisse en termes d’efficacité, j’avais tendance à pencher vers la scission et à rejoindre la mise en œuvre dans le passé sans penser à la performance. Quand je me suis demandé ce qui était le plus efficace et de quelle marge, je l'ai utilisé comme excuse pour le savoir.

Sur mon ordinateur Windows 8 sous Chrome, l'implémentation basée sur les expressions régulières est la plus rapide, l'implémentation split et join étant 53% plus lente. Cela signifie que les expressions régulières sont deux fois plus rapides pour l’entrée lorem ipsum que j’ai utilisée.

Découvrez ceci benchmark en exécutant ces deux implémentations l'une contre l'autre.


Comme noté dans le commentaire ci-dessous par @ThomasLeduc et autres, il pourrait y avoir un problème avec l'implémentation basée sur les expressions régulières si search contient certains caractères réservés en tant que caractères spéciaux dans les expressions régulières . L'implémentation suppose que l'appelant échappera la chaîne au préalable ou ne transmettra que les chaînes sans les caractères de la table dans Expressions régulières (MDN).

MDN fournit également une implémentation pour échapper à nos chaînes. Ce serait bien si cela était aussi normalisé en tant que RegExp.escape(str), mais hélas, cela n'existe pas:

function escapeRegExp(str) {
  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
}

Nous pourrions appeler escapeRegExp dans notre implémentation String.prototype.replaceAll, mais je ne sais pas dans quelle mesure cela affectera les performances (potentiellement, même pour les chaînes pour lesquelles l'échappement n'est pas nécessaire, comme toutes les chaînes alphanumériques).

2009
Cory Gross
str = str.replace(/abc/g, '');

En réponse au commentaire:

var find = 'abc';
var re = new RegExp(find, 'g');

str = str.replace(re, '');

En réponse au commentaire de Cliquez sur le vote positif , vous pourriez le simplifier encore plus:

function replaceAll(str, find, replace) {
    return str.replace(new RegExp(find, 'g'), replace);
}

Remarque: Les expressions régulières contiennent des caractères spéciaux (méta). Par conséquent, il est dangereux de passer aveuglément un argument dans la fonction find ci-dessus sans le pré-traiter pour échapper à ces caractères. Ceci est couvert dans le Mozilla Developer Network 's Guide JavaScript sur les expressions régulières , où ils présentent la fonction utilitaire suivante:

function escapeRegExp(str) {
    return str.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");
}

Ainsi, afin de rendre la fonction replaceAll() ci-dessus plus sûre, vous pouvez la modifier comme suit si vous incluez également escapeRegExp:

function replaceAll(str, find, replace) {
    return str.replace(new RegExp(escapeRegExp(find), 'g'), replace);
}
3844
Sean Bright

Remarque: Ne l'utilisez pas dans le code réel.

Comme alternative aux expressions régulières pour une chaîne littérale simple, vous pouvez utiliser

str = "Test abc test test abc test...".split("abc").join("");

Le schéma général est

str.split(search).join(replacement)

Auparavant, c'était plus rapide que d'utiliser replaceAll et une expression régulière, mais cela ne semble plus être le cas dans les navigateurs modernes. Donc, cela ne devrait vraiment être utilisé que comme un hack rapide pour éviter de devoir échapper à l'expression régulière, pas dans du code réel.

1244
Matthew Crumley

L'utilisation d'une expression régulière avec l'indicateur g remplacera tous les éléments suivants:

someString = 'the cat looks like a cat';
anotherString = someString.replace(/cat/g, 'dog');
// anotherString now contains "the dog looks like a dog"

Voir ici aussi

553
Adam A

Voici une fonction de prototype de chaîne basée sur la réponse acceptée:

String.prototype.replaceAll = function (find, replace) {
    var str = this;
    return str.replace(new RegExp(find, 'g'), replace);
};

MODIFIER 

Si votre find contient des caractères spéciaux, vous devez les échapper:

String.prototype.replaceAll = function (find, replace) {
    var str = this;
    return str.replace(new RegExp(find.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'), 'g'), replace);
};

Fiddle: http://jsfiddle.net/cdbzL/

93
jesal

Mettre à jour:

Il est un peu tard pour une mise à jour, mais comme je viens de trébucher sur cette question et de constater que ma réponse précédente ne me convient pas. Puisque la question impliquait de remplacer un seul mot, il est incroyable que personne n'ait pensé à utiliser les limites de Word (\b)

'a cat is not a caterpillar'.replace(/\bcat\b/gi,'dog');
//"a dog is not a caterpillar"

C'est un regex simple qui évite de remplacer des parties de mots dans la plupart des cas. Cependant, un tiret - est toujours considéré comme une limite de Word. Donc les conditionnels peuvent être utilisés dans ce cas pour éviter de remplacer des chaînes comme cool-cat:

'a cat is not a cool-cat'.replace(/\bcat\b/gi,'dog');//wrong
//"a dog is not a cool-dog" -- nips
'a cat is not a cool-cat'.replace(/(?:\b([^-]))cat(?:\b([^-]))/gi,'$1dog$2');
//"a dog is not a cool-cat"

fondamentalement, cette question est la même que celle ici: Javascript remplace "" "par" ""

@ Mike, vérifie la réponse que j'ai donnée là-bas ... l'expression rationnelle n'est pas le seul moyen de remplacer plusieurs occurrences d'une souscription, loin de là. Pensez flexible, pensez à diviser!

var newText = "the cat looks like a cat".split('cat').join('dog');

Alternativement, pour éviter de remplacer des parties Word - ce que la réponse approuvée fera aussi! Vous pouvez contourner ce problème en utilisant des expressions régulières qui sont, je l’admets, un peu plus complexes et, par conséquent, un peu plus lentes:

var regText = "the cat looks like a cat".replace(/(?:(^|[^a-z]))(([^a-z]*)(?=cat)cat)(?![a-z])/gi,"$1dog");

La sortie est identique à la réponse acceptée, toutefois, en utilisant l'expression/cat/g sur cette chaîne:

var oops = 'the cat looks like a cat, not a caterpillar or coolcat'.replace(/cat/g,'dog');
//returns "the dog looks like a dog, not a dogerpillar or cooldog" ?? 

Oups en effet, ce n'est probablement pas ce que vous voulez. Qu'est-ce que c'est alors? IMHO, une regex qui ne remplace que "cat" conditionnellement. (c.-à-d. ne faisant pas partie d'un mot), comme suit:

var caterpillar = 'the cat looks like a cat, not a caterpillar or coolcat'.replace(/(?:(^|[^a-z]))(([^a-z]*)(?=cat)cat)(?![a-z])/gi,"$1dog");
//return "the dog looks like a dog, not a caterpillar or coolcat"

À mon avis, cela répond à vos besoins. Ce n'est pas complet, bien sûr, mais cela devrait suffire à vous aider à démarrer. Je recommande de lire un peu plus sur ces pages. Cela s'avérera utile pour perfectionner cette expression afin de répondre à vos besoins spécifiques.

http://www.javascriptkit.com/jsref/regexp.shtml

http://www.regular-expressions.info


Ajout final:

Étant donné que cette question suscite encore beaucoup de points de vue, j'ai pensé ajouter un exemple de .replace utilisé avec une fonction de rappel. Dans ce cas, l’expression and est considérablement simplifiée, ce qui permet une plus grande flexibilité, comme le remplacement par une capitalisation correcte ou le remplacement simultané de cat et cats:

'Two cats are not 1 Cat! They\'re just cool-cats, you caterpillar'
   .replace(/(^|.\b)(cat)(s?\b.|$)/gi,function(all,char1,cat,char2)
    {
       //check 1st, capitalize if required
       var replacement = (cat.charAt(0) === 'C' ? 'D' : 'd') + 'og';
       if (char1 === ' ' && char2 === 's')
       {//replace plurals, too
           cat = replacement + 's';
       }
       else
       {//do not replace if dashes are matched
           cat = char1 === '-' || char2 === '-' ? cat : replacement;
       }
       return char1 + cat + char2;//return replacement string
    });
//returns:
//Two dogs are not 1 Dog! They're just cool-cats, you caterpillar
76

Correspondre à une expression régulière globale:

anotherString = someString.replace(/cat/g, 'dog');
57
scronide
str = str.replace(/abc/g, '');

Ou essayez la fonction replaceAll à partir d'ici:

Quelles sont les méthodes JavaScript utiles qui étend les objets intégrés?

str = str.replaceAll('abc', ''); OR

var search = 'abc';
str = str.replaceAll(search, '');

EDIT: Clarification sur replaceAll disponibilité

La méthode 'replaceAll' est ajoutée au prototype de String. Cela signifie qu'il sera disponible pour tous les objets/littéraux de chaîne.

Par exemple.

var output = "test this".replaceAll('this', 'that');  //output is 'test that'.
output = output.replaceAll('that', 'this'); //output is 'test this'
39
SolutionYogi

Supposons que vous souhaitiez remplacer tous les "abc" par "x":

let some_str = 'abc def def lom abc abc def'.split('abc').join('x')
console.log(some_str) //x def def lom x x def

J'essayais de penser à quelque chose de plus simple que de modifier le prototype de chaîne.

34
Emilio Grisolía

Utilisez une expression régulière:

str.replace(/abc/g, '');
32
Donnie DeBoer

Remplacer les guillemets simples:

function JavaScriptEncode(text){
    text = text.replace(/'/g,''')
    // More encode here if required

    return text;
}
30
Chris Rosete

Ce sont les méthodes les plus courantes et lisibles.

var str = "Test abc test test abc test test test abc test test abc"

Méthode 01:

str = str.replace(/abc/g, "replaced text");

Méthode 02:

str = str.split("abc").join("replaced text");

Méthode 03:

str = str.replace(new RegExp("abc", "g"), "replaced text");

Méthode 04:

while(str.includes("abc")){
    str = str.replace("abc", "replaced text");
}

Sortie:

console.log(str);
// Test replaced text test test replaced text test test test replaced text test test replaced text
29
Adnan Toky

// boucle jusqu'à ce que le nombre d'occurrences atteigne 0. OR simplement copier/coller

    function replaceAll(find, replace, str) 
    {
      while( str.indexOf(find) > -1)
      {
        str = str.replace(find, replace);
      }
      return str;
    }
23
Raseela
str = str.replace(new RegExp("abc", 'g'), "");

a fonctionné mieux pour moi que les réponses ci-dessus. so new RegExp("abc", 'g') crée une RegExp qui correspond à toutes les occurrences (drapeau 'g') du texte ("abc"). La deuxième partie correspond à ce qui doit être remplacé. Dans votre cas, chaîne vide ("") .str est la chaîne, et nous devons la remplacer, car replace(...) renvoie simplement le résultat, mais pas les substitutions. Dans certains cas, vous voudrez peut-être utiliser cela.

22
csomakk

Utiliser RegExp dans JavaScript pourrait faire le travail pour vous, faites simplement quelque chose comme ci-dessous, n'oubliez pas le /g après lequel se démarquer pour global :

var str ="Test abc test test abc test test test abc test test abc";
str = str.replace(/abc/g, '');

Si vous pensez à la réutilisation, créez une fonction pour le faire pour vous, mais ce n'est pas recommandé car c'est une fonction à une seule ligne, mais encore une fois, si vous utilisez beaucoup cela, vous pouvez écrire quelque chose comme ceci:

String.prototype.replaceAll = String.prototype.replaceAll || function(string, replaced) {
  return this.replace(new RegExp(string, 'g'), replaced);
};

et utilisez-le simplement dans votre code, encore et encore, comme ci-dessous:

var str ="Test abc test test abc test test test abc test test abc";
str = str.replaceAll('abc', '');

Mais comme je l’ai dit plus tôt, cela ne fera pas une grande différence en termes de lignes à écrire ou de performances, seule la mise en cache de la fonction peut accélérer certaines performances sur les chaînes longues et constituer une bonne pratique de code DRY vouloir réutiliser.

21
Alireza

Si ce que vous voulez trouver est déjà dans une chaîne et que vous n'avez pas d'escaper une expression rationnelle, vous pouvez utiliser join/split:

    function replaceMulti(haystack, needle, replacement)
    {
        return haystack.split(needle).join(replacement);
    }

    someString = 'the cat looks like a cat';
    console.log(replaceMulti(someString, 'cat', 'dog'));

18
rakslice
function replaceAll(str, find, replace) {
  var i = str.indexOf(find);
  if (i > -1){
    str = str.replace(find, replace); 
    i = i + replace.length;
    var st2 = str.substring(i);
    if(st2.indexOf(find) > -1){
      str = str.substring(0,i) + replaceAll(st2, find, replace);
    }       
  }
  return str;
}
16
Tim Rivoli

J'aime cette méthode (elle a l'air un peu plus propre):

text = text.replace(new RegExp("cat","g"), "dog"); 
14
Owen
var str = "ff ff f f a de def";
str = str.replace(/f/g,'');
alert(str);

http://jsfiddle.net/ANHR9/

12
pkdkk
while (str.indexOf('abc') !== -1)
{
    str = str.replace('abc', '');
}
12
zdennis

Si la chaîne contient un motif similaire à abccc, vous pouvez utiliser ceci:

str.replace(/abc(\s|$)/g, "")
11
mostafa elmadany

Les réponses précédentes sont beaucoup trop compliquées. Utilisez simplement la fonction de remplacement comme ceci:

str.replace(/your_regex_pattern/g, replacement_string);

Exemple:

var str = "Test abc test test abc test test test abc test test abc";

var res = str.replace(/[abc]+/g, "");

console.log(res);

11
Black

Si vous essayez de vous assurer que la chaîne que vous recherchez n'existera pas, même après le remplacement, vous devez utiliser une boucle.

Par exemple:

var str = 'test aabcbc';
str = str.replace(/abc/g, '');

Une fois terminé, vous aurez toujours 'test abc'!

La boucle la plus simple pour résoudre ce problème serait:

var str = 'test aabcbc';
while (str != str.replace(/abc/g, '')){
   str.replace(/abc/g, '');
}

Mais cela exécute le remplacement deux fois pour chaque cycle. Peut-être (au risque d’être rejeté) qui peut être combiné pour une forme légèrement plus efficace mais moins lisible:

var str = 'test aabcbc';
while (str != (str = str.replace(/abc/g, ''))){}
// alert(str); alerts 'test '!

Cela peut être particulièrement utile lorsque vous recherchez des chaînes en double.
Par exemple, si nous avons 'a , b' et que nous souhaitons supprimer toutes les virgules en double.
[Dans ce cas, on pourrait faire .replace (/, +/g, ','), mais à un moment donné, la regex devient assez complexe et lente pour la boucle.]

9
SamGoody

Bien que certaines personnes aient mentionné l’utilisation de regex, il existe une meilleure approche si vous souhaitez remplacer le texte, quel que soit le cas. Comme en majuscule ou en minuscule. Utilisez la syntaxe ci-dessous

//Consider below example
originalString.replace(/stringToBeReplaced/gi, '');

//Output will be all the occurrences removed irrespective of casing.

Vous pouvez vous référer à l'exemple détaillé ici .

9
Cheezy Code

La fonction suivante fonctionne pour moi:

String.prototype.replaceAllOccurence = function(str1, str2, ignore)
{
    return this.replace(new RegExp(str1.replace(/([\/\,\!\\\^\$\{\}\[\]\(\)\.\*\+\?\|\<\>\-\&])/g,"\\$&"),(ignore?"gi":"g")),(typeof(str2)=="string")?str2.replace(/\$/g,"$$$$"):str2);
} ;

Appelez maintenant les fonctions comme ceci:

"you could be a Project Manager someday, if you work like this.".replaceAllOccurence ("you", "I");

Il vous suffit de copier et coller ce code dans la console de votre navigateur pour le tester.

7
Sandeep Gantait

Vous pouvez simplement utiliser la méthode ci-dessous

/**
 * Replace all the occerencess of $find by $replace in $originalString
 * @param  {originalString} input - Raw string.
 * @param  {find} input - Target key Word or regex that need to be replaced.
 * @param  {replace} input - Replacement key Word
 * @return {String}       Output string
 */
function replaceAll(originalString, find, replace) {
  return originalString.replace(new RegExp(find, 'g'), replace);
};
7
tk_

Il suffit d'ajouter /g 

document.body.innerHTML = document.body.innerHTML.replace('hello', 'hi');

à

// Replace 'hello' string with /hello/g regular expression.
document.body.innerHTML = document.body.innerHTML.replace(/hello/g, 'hi');

/g signifie global

7
Reza Fahmi

J'ai résolu ce problème par une simple ligne de code.

str.replace(/Current string/g, "Replaced string");

Consultez l'exemple sur jsfiddle https://jsfiddle.net/pot6whnx/1/

7
Riajul Islam

J'utilise p pour stocker le résultat du remplacement précédent de la récursivité:

function replaceAll(s, m, r, p) {
    return s === p || r.contains(m) ? s : replaceAll(s.replace(m, r), m, r, s);
}

Il remplacera toutes les occurrences dans la chaîne s jusqu'à ce qu'il soit possible:

replaceAll('abbbbb', 'ab', 'a') → 'abbbb' → 'abbb' → 'abb' → 'ab' → 'a'

Pour éviter la boucle infinie, je vérifie si le remplacement r contient une correspondance m :

replaceAll('abbbbb', 'a', 'ab') → 'abbbbb'
6
Termininja

La plupart des gens font probablement cela pour encoder une URL. Pour encoder une URL, vous ne devez pas seulement considérer les espaces, mais convertir la chaîne entière correctement avec encodeURI.

encodeURI("http://www.google.com/a file with spaces.html")

obtenir:

http://www.google.com/a%20file%20with%20spaces.html
5
User

En termes de performances liées aux réponses principales ce sont quelques tests en ligne .

Certains tests de performances utilisant console.time() (qui fonctionnent le mieux dans votre propre console sont décrits ci-dessous, mais le temps est très court pour que l’extrait le soit dans l’extrait).

console.time('split and join');
"javascript-test-find-and-replace-all".split('-').join(' ');
console.timeEnd('split and join')

console.time('regular expression');
"javascript-test-find-and-replace-all".replace(new RegExp('-', 'g'), ' ');
console.timeEnd('regular expression');

console.time('while');
let str1 = "javascript-test-find-and-replace-all";
while (str1.indexOf('-') !== -1) {
    str1 = str1.replace('-', ' ');
}
console.timeEnd('while');

La chose intéressante à noter est que si vous les exécutez plusieurs fois, les résultats sont toujours différents même si la solution RegExp semble la plus rapide en moyenne et la solution de boucle while la plus lente.

4
Ferie

Ma mise en œuvre, très explicite

function replaceAll(string, token, newtoken) {
    if(token!=newtoken)
    while(string.indexOf(token) > -1) {
        string = string.replace(token, newtoken);
    }
    return string;
}
4
Vitim.us

Pour remplacer tout type de caractères, essayez ce code:

Suppose we have need to send " and \ in my string, then we will convert it " to \" and \ to \\

Donc, cette méthode va résoudre ce problème.

String.prototype.replaceAll = function (find, replace) {
     var str = this;
     return str.replace(new RegExp(find.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'), 'g'), replace);
 };

var message = $('#message').val();
             message = message.replaceAll('\\', '\\\\'); /*it will replace \ to \\ */
             message = message.replaceAll('"', '\\"');   /*it will replace " to \\"*/

J'utilisais Ajax et j'avais besoin d'envoyer des paramètres au format JSON. Alors ma méthode ressemble à ceci:

 function sendMessage(source, messageID, toProfileID, userProfileID) {

     if (validateTextBox()) {
         var message = $('#message').val();
         message = message.replaceAll('\\', '\\\\');
         message = message.replaceAll('"', '\\"');
         $.ajax({
             type: "POST",
             async: "false",
             contentType: "application/json; charset=utf-8",
             url: "services/WebService1.asmx/SendMessage",
             data: '{"source":"' + source + '","messageID":"' + messageID + '","toProfileID":"' + toProfileID + '","userProfileID":"' + userProfileID + '","message":"' + message + '"}',
             dataType: "json",
             success: function (data) {
                 loadMessageAfterSend(toProfileID, userProfileID);
                 $("#<%=PanelMessageDelete.ClientID%>").hide();
                 $("#message").val("");
                 $("#delMessageContainer").show();
                 $("#msgPanel").show();
             },
             error: function (result) {
                 alert("message sending failed");
             }
         });
     }
     else {
         alert("Please type message in message box.");
         $("#message").focus();

     }
 }

 String.prototype.replaceAll = function (find, replace) {
     var str = this;
     return str.replace(new RegExp(find.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'), 'g'), replace);
 };
4
SiwachGaurav

Dans mes applications, j'utilise une fonction personnalisée qui est la plus puissante à cet effet, et même en enveloppant la solution split/join dans un cas plus simple, elle est un peu plus rapide dans Chrome 60etFirefox 54 ( JSBEN.CH ) que d'autres solutions. Mon ordinateur exécute Windows 7 64 bits.

L'avantage est que cette fonction personnalisée peut gérer plusieurs substitutions en même temps à l'aide de chaînes ou de caractères, ce qui peut constituer un raccourci pour certaines applications.

Comme une solution split/join ci-dessus, la solution ci-dessous ne pose aucun problème avec les caractères d'échappement, contrairement à l'approche d'expression régulière.

  function replaceAll(s,find,repl,caseOff,byChar){
  if (arguments.length<2)  return false; 
  var destDel = ! repl;       // if destDel delete all keys from target
  var isString = !! byChar;   // if byChar, replace set of characters 
  if (typeof find !==typeof repl && ! destDel)  return false; 
  if (isString  &&  (typeof find!=="string"))   return false; 

  if (! isString &&  (typeof find==="string"))  {
    return s.split(find).join(destDel?"":repl);
  }

  if ((! isString)  &&  ( ! Array.isArray(find) ||
          ( ! Array.isArray(repl) && ! destDel)   ))  return false;

     // if destOne replace all strings/characters by just one element
  var destOne = destDel ? false : (repl.length===1);   

     // Generally source and destination should have the same size
  if (! destOne && ! destDel && find.length!==repl.length)  return false    

  var prox,sUp,findUp,i,done;   
  if (caseOff)  {    // case insensitive    
       // Working with uppercase keys and target 
    sUp = s.toUpperCase();   
    if (isString)
       findUp = find.toUpperCase()   
    else
       findUp = find.map(function(el){  return el.toUpperCase();});    

  } else  {         // case sensitive
     sUp = s;
     findUp =find.slice();  // clone array/string
  }  

  done = new Array(find.length);  // size: number of keys
  done.fill(null);              

  var pos = 0;       // initial position in target s
  var r = "";   // initial result
  var aux, winner;
  while (pos < s.length)  {       // Scanning the target
     prox  = Number.MAX_SAFE_INTEGER;
     winner = -1;  // no winner at start
     for (i=0;i<findUp.length;i++)   // find next occurence for each string
       if (done[i]!==-1) {    // key still alive
             // Never search for the Word/char or is over?
         if (done[i]===null || done[i]<pos)  { 
           aux = sUp.indexOf(findUp[i],pos);
           done[i]=aux;  // Save the next occurrence
         } else
           aux = done[i]   // restore the position of last search
         if (aux<prox && aux!==-1) {   // if next occurrence is minimum
           winner = i;     // save it  
           prox = aux;
         }  
       }  // not done

      if (winner===-1) {   // No matches forward
         r += s.slice(pos);   
         break;
      } // no winner

      // found the character or string key in the target

      i = winner;  // restore the winner
      r += s.slice(pos,prox);   // update piece before the match

            // Append the replacement in target 
      if (! destDel) r += repl[ destOne?0:i ];  
      pos = prox + ( isString?1:findUp[i].length );       // go after match

  }  // loop
  return r;  // return the resulting string
}

La documentation est ci-dessous

           replaceAll    
 Syntax    
 ======     
      replaceAll(s,find,[ repl ,caseOff, byChar)     

 Parameters    
 ==========    

   "s" is a string target of replacement.    
   "find" can be a string or array of strings.     
   "repl" should be the same type than "find" or empty     

  if "find" is a string, it is a simple replacement for      
    all "find" occurrences in "s" by string "repl"    

  if "find" is an array, it will replaced each string in "find"    
    that occurs in "s" for corresponding string in "repl" array.
  The replace specs are independent: A replacement part cannot    
    be replaced again. 


  if "repl" is empty all "find" occurrences in "s" will be deleted.   
  if "repl" has only one character or element,    
      all occurrences in "s" will be replaced for that one.   

  "caseOff" is true if replacement is case insensitive     
       (default is FALSE)

  "byChar" is true when replacement is based on set of characters.    
  Default is false   

  if "byChar", it will be replaced in "s" all characters in "find"   
  set of characters for corresponding character in  "repl"
  set of characters   

 Return   
 ======   
  the function returns the new string after the replacement.  

Pour être honnête, j’ai exécuté le test benchmark sans test de paramètre. 

Voici mon ensemble de test, en utilisant Node.js

function l() { return console.log.apply(null, arguments); }

var k=0;
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      ["ri","nea"],["do","fa"]));  //1
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      ["ri","nea"],["do"]));  //2
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      ["ri","nea"]));  //3
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
     "aeiou","","",true));  //4
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      "aeiou","a","",true));  //5
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      "aeiou","uoiea","",true));  //6
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      "aeiou","uoi","",true));  //7
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      ["ri","nea"],["do","fa","leg"]));  //8
l(++k,replaceAll("BANANA IS A RIPE FRUIT HARVESTED NEAR THE RIVER",
      ["ri","nea"],["do","fa"]));  //9
l(++k,replaceAll("BANANA IS A RIPE FRUIT HARVESTED NEAR THE RIVER",
      ["ri","nea"],["do","fa"],true)); //10
return;

Et les résultats:

1 'La banane est un fruit de la dope récolté loin du passé'
2 'la banane est un fruit de la dope récolté depuis le début'
3 'la banane est un fruit de pie récolté dans le ver'
4 'bnn s rp frt hrvstd nr th rvr'
5 'la banane comme rapa fraat harvastad naar tha ravar'
6 'Bununu est u ripo frait hurvostod nour tho rivor'
7 faux
8 faux
9 'BANANA IS UN FRUITS COLLECTIFS RÉCOLTÉS AU BORD DE LA RIVIÈRE'
10 'BANANA IS UN DOPÉ FRUIT RÉCOLTÉ FAVORISÉ' 

3
Paulo Buchsbaum

Ceci peut être réalisé en utilisant Regex. Peu de combinaisons qui pourraient aider quelqu'un,

var Word = "this,\\ .is*a*test,    '.and? / only /     'a \ test?";
var stri = "This      is    a test         and only a        test";

Pour remplacer tous les caractères non alpha,

console.log(Word.replace(/([^a-z])/g,' ').replace(/ +/g, ' ')); 
Result: [this is a test and only a test]

Pour remplacer plusieurs espaces continus par un espace,

console.log(stri.replace(/  +/g,' ')); 
Result: [This is a test and only a test]

Pour remplacer tous les caractères *,

console.log(Word.replace(/\*/g,'')); 
Result: [this,\ .isatest,    '.and? / only /     'a  test?]

Pour remplacer les points d'interrogation (?)

console.log(Word.replace(/\?/g,'#')); 
Result: [this,\ .is*a*test,    '.and# / only /     'a  test#]

Pour remplacer les guillemets,

console.log(Word.replace(/'/g,'#'));  
Result: [this,\ .is*a*test,    #.and? / only /     #a  test?]

Pour remplacer tous les caractères,

console.log(Word.replace(/,/g,'')); 
Result: [this\ .is*a*test    '.and? / only /     'a  test?]

Pour remplacer un mot spécifique,

console.log(Word.replace(/test/g,'')); 
Result: [this,\ .is*a*,    '.and? / only /     'a  ?]

Pour remplacer la barre oblique inverse,

console.log(Word.replace(/\\/g,''));  
Result: [this, .is*a*test,    '.and? / only /     'a  test?]

Pour remplacer la barre oblique,

console.log(Word.replace(/\//g,''));  
Result: [this,\ .is*a*test,    '.and?  only      'a  test?]

Pour remplacer tous les espaces,

console.log(Word.replace(/ /g,'#'));  
Result: [this,\#.is*a*test,####'.and?#/#only#/#####'a##test?]

Pour remplacer les points,

console.log(Word.replace(/\./g,'#')); 
Result: [this,\ #is*a*test,    '#and? / only /     'a  test?]
3
prime
function replaceAll(str, find, replace) {
    var $r="";
    while($r!=str){ 
        $r = str;
        str = str.replace(find, replace);
    }
    return str;
}
3
theWalker

Voici le code de travail avec prototype:

String.prototype.replaceAll = function(find, replace) {
    var str = this;
    return str.replace(new RegExp(find.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1"), 'g'), replace);
};
3
Nivesh Saharan

Pour unique valeurs remplaçables

String.prototype.replaceAll = function(search_array, replacement_array) {
  //
  var target = this;
  //
  search_array.forEach(function(substr, index) {
    if (typeof replacement_array[index] != "undefined") {
      target = target.replace(new RegExp(substr, 'g'), replacement_array[index])
    }
  });
  //
  return target;
};

//  Use:
var replacedString = "This topic commented on :year. Talking :question.".replaceAll([':year', ':question'], ['2018', 'How to replace all occurrences of a string in JavaScript']);
//
console.log(replacedString);

2
TheAivis

Méthode 1

Essayez d'implémenter l'expression régulière

"Test abc test test abc test test test test abc test test abc". Remplacer (/\abc/g, '');

Méthode 2

Split et rejoindre. Diviser avec abc et rejoindre avec un espace vide

"Test abc test test abc test test test test abc test test abc" .split ("abc"). Join ("")

2
ashish

Si l'utilisation d'une bibliothèque est une option pour vous, vous bénéficierez des tests et du support de la communauté associés à une fonction de bibliothèque. Par exemple, la bibliothèque string.js a une fonction replaceAll () qui fait ce que vous cherchez:

// Include a reference to the string.js library and call it (for example) S.
str = S(str).replaceAll('abc', '').s;
2
Guy

Dans la chaîne, premier élément, rechercher et remplacer  

var str = '[{"id":1,"name":"karthikeyan.a","type":"developer"}]'
var i = str.replace('"[','[').replace(']"',']');
console.log(i,'//first element search and replace')

Dans la chaîne recherche globale et remplacer  

var str = '[{"id":1,"name":"karthikeyan.a","type":"developer"}]'
var j = str.replace(/\"\[/g,'[').replace(/\]\"/g,']');
console.log(j,'//global search and replace')

2
KARTHIKEYAN.A

Je souhaite simplement partager ma solution, basée sur certaines des fonctionnalités des dernières versions de JavaScript:

   var str = "Test abc test test abc test test test abc test test abc";

   var result = str.split(' ').reduce((a, b) => {
      return b == 'abc' ? a : a + ' ' + b;   })

  console.warn(result)
1
Andrés

J'utilise split et rejoindre ou ce funcion

function replaceAll( text, busca, reemplaza ){
  while (text.toString().indexOf(busca) != -1)
      text = text.toString().replace(busca,reemplaza);
  return text;
}
1
VhsPiceros

Cela peut être résolu à l'aide d'expressions régulières et du drapeau g, ce qui signifie qu'il ne faut pas s'arrêter après avoir trouvé la première correspondance. Vraiment, les expressions régulières sauvent des vies!

function replaceAll(string, pattern, replacement) {
    return string.replace(new RegExp(pattern, "g"), replacement);
}

// or if you want myString.replaceAll("abc", "");

String.prototype.replaceAll = function(pattern, replacement) {
    return this.replace(new RegExp(pattern, "g"), replacement);
};
1
C. Morgan

Pour remplacer une seule utilisation du temps:

var res = str.replace('abc', "");

Pour remplacer plusieurs fois, utilisez:

var res = str.replace(/abc/g, "");
1
Indrajeet Singh

Cela devrait marcher.

String.prototype.replaceAll = function (search, replacement){
var str1 = this.replace(search, replacement);
var str2 = this;
while(str1 != str2){
str2 = str1;
str1 = str1.replace(search, replacement);
}
return str1;
}

Exemple:

Console.log("Steve is the best character in minecraft".replaceAll("Steve" ,"Alex"));
1
jessie tessie

Le moyen le plus simple de le faire sans utiliser d’expression rationnelle est de scinder et de rejoindre le même code ici:

var str="Test abc test test abc test test test abc test test abc";
str.split('abc').join('')
1
sajadre

Cochez cette réponse peut aider et j'ai utilisé dans mon projet.

function replaceAll(searchString, replaceString, str) {
   return str.split(searchString).join(replaceString);
}
replaceAll('abc', '',"Test abc test test abc test test test abc test test abc" ); // "Test  test test  test test test  test test "
0
Raghavendra S

Essaye ça:

String.prototype.replaceAll = function (sfind, sreplace) {
    var str = this;

    while (str.indexOf(sfind) > -1) {
        str = str.replace(sfind, sreplace);
    }

    return str;
};
0
Antonio Mirarchi

Vous pouvez le faire sans Regex, mais vous devez faire attention si le texte de remplacement contient le texte recherché.

par exemple.

replaceAll("nihIaohi", "hI", "hIcIaO", true)

Voici donc une variante appropriée de replaceAll, y compris string-prototype:

function replaceAll(str, find, newToken, ignoreCase)
{
    let i = -1;

    if (!str)
    {
        // Instead of throwing, act as COALESCE if find == null/empty and str == null
        if ((str == null) && (find == null))
            return newToken;

        return str;
    }

    if (!find) // sanity check 
        return str;

    ignoreCase = ignoreCase || false;
    find = ignoreCase ? find.toLowerCase() : find;

    while ((
        i = (ignoreCase ? str.toLowerCase() : str).indexOf(
            find, i >= 0 ? i + newToken.length : 0
        )) !== -1
    )
    {
        str = str.substring(0, i) +
            newToken +
            str.substring(i + find.length);
    } // Whend 

    return str;
}

Ou, si vous voulez avoir une fonction de prototype de chaîne:

String.prototype.replaceAll = function (find, replace) {
    let str = this;

    let i = -1;

    if (!str)
    {
        // Instead of throwing, act as COALESCE if find == null/empty and str == null
        if ((str == null) && (find == null))
            return newToken;

        return str;
    }

    if (!find) // sanity check 
        return str;

    ignoreCase = ignoreCase || false;
    find = ignoreCase ? find.toLowerCase() : find;

    while ((
        i = (ignoreCase ? str.toLowerCase() : str).indexOf(
            find, i >= 0 ? i + newToken.length : 0
        )) !== -1
    )
    {
        str = str.substring(0, i) +
            newToken +
            str.substring(i + find.length);
    } // Whend 

    return str;
};
0
Stefan Steiger
 var myName = 'r//i//n//o//l////d';
  var myValidName = myName.replace(new RegExp('\//', 'g'), ''); > // rinold
  console.log(myValidName);

var myPetName = 'manidog';
var renameManiToJack = myPetName.replace(new RegExp('mani', 'g'), 'jack'); > // jackdog
0
Rinold

Toutes les réponses sont acceptées, vous pouvez le faire de plusieurs façons. Voici un truc pour faire ça.

const str = "Test abc test test abc test test test abc test test abc";

const compare = "abc";
arrayStr = str.split(" ");
arrayStr.forEach((element, index) => {
  if (element == compare) {
    arrayStr.splice(index, 1);
  }
});
const newString = arrayStr.join(" ");
console.log(newString);
0
Nouman Dilshad

La meilleure solution, afin de remplacer tout caractère, nous utilisons ces fonctions indexOf(), includes(), substring() pour remplacer matched String par le provided String dans la chaîne actuelle.

  • String.indexOf() fonction est de trouver la nth correspondre à la position de l'index.
  • String.includes() méthode détermine si une chaîne peut être trouvée dans une autre chaîne, en renvoyant la valeur true ou false, selon le cas.
  • String.substring() function consiste à obtenir les parties de String (preceding, exceding). Ajout de la chaîne de remplacement entre ces pièces pour générer la chaîne de retour finale.

La fonction suivante permet d'utiliser n'importe quel caractère .
où as RegExp n'autorisera pas un caractère spécial comme ** et certains caractères doivent être échappés comme $.

String.prototype.replaceAllMatches = function(obj) { // Obj format: { 'matchkey' : 'replaceStr' }
    var retStr = this;
    for (var x in obj) {
        //var matchArray = retStr.match(new RegExp(x, 'ig'));
        //for (var i = 0; i < matchArray.length; i++) {
        var prevIndex = retStr.indexOf(x); // matchkey = '*', replaceStr = '$*' While loop never ends.
        while (retStr.includes(x)) {
            retStr = retStr.replaceMatch(x, obj[x], 0);
            var replaceIndex = retStr.indexOf(x);
            if( replaceIndex <  prevIndex + (obj[x]).length) {
                break;
            } else {
                prevIndex = replaceIndex;
            }
        }
    }
    return retStr;
};
String.prototype.replaceMatch = function(matchkey, replaceStr, matchIndex) {
    var retStr = this, repeatedIndex = 0;
    //var matchArray = retStr.match(new RegExp(matchkey, 'ig'));
    //for (var x = 0; x < matchArray.length; x++) {
    for (var x = 0; (matchkey != null) && (retStr.indexOf(matchkey) > -1); x++) {
        if (repeatedIndex == 0 && x == 0) {
            repeatedIndex = retStr.indexOf(matchkey);
        } else { // matchIndex > 0
            repeatedIndex = retStr.indexOf(matchkey, repeatedIndex + 1);
        }
        if (x == matchIndex) {
            retStr = retStr.substring(0, repeatedIndex) + replaceStr + retStr.substring(repeatedIndex + (matchkey.length));
            matchkey = null; // To break the loop.
        }
    }
    return retStr;
};

Nous pouvons également utiliser un objet d'expression régulière pour faire correspondre un texte à un motif. Les fonctions suivantes sont des objets d’expression régulière.

Vous obtiendrez SyntaxError lorsque vous utilisez une expression régulière non valide telle que '**'.

  • String.replace() function est utilisé pour remplacer la chaîne spécifiée par la chaîne donnée.
  • String.match() function permet de trouver combien de fois la chaîne est répétée.
  • RegExp.prototype.test méthode exécute une recherche d'une correspondance entre une expression régulière et une chaîne spécifiée. Renvoie vrai ou faux.
String.prototype.replaceAllRegexMatches = function(obj) { // Obj format: { 'matchkey' : 'replaceStr' }
    var retStr = this;
    for (var x in obj) {
        retStr = retStr.replace(new RegExp(x, 'ig'), obj[x]);
    }
    return retStr;
};

Notez que les expressions régulières sont écrites sans guillemets.


Exemples à utiliser ci-dessus:

var str = "yash yas $dfdas.**";
console.log('String : ', str);

// No need to escape any special Character
console.log('Index Matched replace : ', str.replaceMatch('as', '*', 2) );
console.log('Index Matched replace : ', str.replaceMatch('y', '~', 1) );
console.log('All Matched replace : ', str.replaceAllMatches({'as' : '**', 'y':'Y', '$':'-'}));
console.log('All Matched replace : ', str.replaceAllMatches({'**' : '~~', '$':'&$&', '&':'%', '~':'>'}));

// You need to escape some special Characters
console.log('REGEX All Matched replace : ', str.replaceAllRegexMatches({'as' : '**', 'y':'Y', '\\$':'-'}));

Résultat:

String :  yash yas $dfdas.**
Index Matched replace :  yash yas $dfd*.**
Index Matched replace :  yash ~as $dfdas.**

All Matched replace :  Y**h Y** -dfd**.**
All Matched replace :  yash yas %$%dfdas.>>

REGEX All Matched replace :  Y**h Y** -dfd**.**

0
Yash