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



Answers

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

En réponse à un commentaire:

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

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

En réponse au commentaire de Click Upvote , vous pouvez 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) et, en tant que tels, il est dangereux de passer aveuglément un argument dans la fonction de find ci-dessus sans le pré-traiter pour échapper ces caractères. Ceci est couvert dans le Guide JavaScript sur les expressions régulières de Mozilla Developer Network , où ils présentent la fonction d'utilité suivante:

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

Ainsi, afin de rendre la fonction replaceAll() plus sûre, il pourrait être modifié comme suit si vous incluez également escapeRegExp :

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

J'ai cette chaîne:

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

Faire

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

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




Mettre à jour:

C'est un peu tard pour une mise à jour, mais depuis que je suis tombé sur cette question, j'ai remarqué que ma réponse précédente n'en est pas une. Puisque la question impliquait de remplacer un seul mot, il est incroyable que personne n'ait pensé à utiliser des limites de mots ( \b )

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

C'est une 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 mot. Ainsi, les conditionnels peuvent être utilisés dans ce cas pour éviter de remplacer les 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"

En gros, cette question est la même que la question ici: Javascript remplace "'" par "' '"

@Mike, cochez la réponse que j'ai donnée ici ... regexp n'est pas le seul moyen de remplacer plusieurs occurrences d'un subsrting, loin de là. Pensez flexible, pensez divisé!

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

Alternativement, pour éviter de remplacer des parties de mot - que la réponse approuvée fera, aussi! Vous pouvez contourner ce problème en utilisant des expressions régulières qui, je le reconnais, sont 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 la même que la réponse acceptée, cependant, 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 remplace seulement «chat» conditionnellement. (c'est-à-dire ne fait pas partie d'un mot), comme ceci:

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"

Ma conjecture est, cela répond à vos besoins. Ce n'est pas complètement étanche, bien sûr, mais cela devrait suffire pour vous aider à démarrer. Je vous recommande de lire plus sur ces pages. Cela s'avérera utile pour perfectionner cette expression pour répondre à vos besoins spécifiques.

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

http://www.regular-expressions.info

Dernier ajout:

Étant donné que cette question obtient encore beaucoup de points de vue, j'ai pensé que je pourrais ajouter un exemple de .replace utilisé avec une fonction de rappel. Dans ce cas, il simplifie considérablement l'expression et offre encore plus de flexibilité, comme le remplacement avec une capitalisation correcte ou le remplacement des cat et des cats en une seule fois:

'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



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;
}



Ajoutez simplement /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




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

Ou essayez la fonction replaceAll d'ici:

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

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

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

EDIT: Clarification sur la disponibilité de replaceAll

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'



function replaceAll(str, find, replace) {
    var $r="";
    while($r!=str){ 
        $r = str;
        str = str.replace(find, replace);
    }
    return str;
}



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);
};



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



C'est la version la plus rapide qui n'utilise pas d'expressions régulières .

Jsperf révisé

replaceAll = function(string, omit, place, prevstring) {
  if (prevstring && string === prevstring)
    return string;
  prevstring = string.replace(omit, place);
  return replaceAll(prevstring, omit, place, string)
}

C'est presque deux fois plus rapide que la méthode split et join.

Comme indiqué dans un commentaire ici, cela ne fonctionnera pas si votre variable omit contient un place , comme dans: replaceAll("string", "s", "ss") , car il sera toujours capable de remplacer une autre occurrence du mot .

Il y a un autre jsperf avec des variantes sur mon remplacement récursif qui vont encore plus vite ( http://jsperf.com/replace-all-vs-split-join/12 )!

  • Mise à jour 27 Juillet 2017: Il semble que RegExp a maintenant la performance la plus rapide dans le Chrome 59 récemment publié.



L'utilisation d'une expression régulière avec l'ensemble d'indicateurs g remplacera tous:

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




Si ce que vous voulez trouver se trouve déjà dans une chaîne, et que vous n'avez pas d'escape regex à portée de main, vous pouvez utiliser join / split:

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

someString = 'the cat looks like a cat';
anotherString = replaceMulti(someString, 'cat', 'dog');



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;
}



Pour remplacer tous les 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 le 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);
 };



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.




La plupart des gens font probablement ceci 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



Related