Comment remplacer tous les points d'une chaîne à l'aide de JavaScript

Je veux remplacer toutes les occurrences d'un point ( .) dans une chaîne JavaScript

Par exemple, j'ai:

var mystring = 'okay.this.is.a.string';

Je veux obtenir: okay this is a string.

Jusqu'à présent, j'ai essayé:

mystring.replace(/./g,' ')

mais cela se termine avec toute la chaîne remplacée par des espaces.

Vous devez échapper au .car il a la signification d'un "caractère arbitraire" dans une expression régulière.

mystring = mystring.replace(/\./g,' ')

Encore une solution facile à comprendre :)

var newstring = mystring.split('.').join(' ');

/**
 * ReplaceAll by Fagner Brack (MIT Licensed)
 * Replaces all occurrences of a substring in a string
 */
String.prototype.replaceAll = function( token, newToken, ignoreCase ) {
    var _token;
    var str = this + "";
    var i = -1;

    if ( typeof token === "string" ) {

        if ( ignoreCase ) {

            _token = token.toLowerCase();

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

        } else {
            return this.split( token ).join( newToken );
        }

    }
return str;
};

alert('okay.this.is.a.string'.replaceAll('.', ' '));

Plus rapide que l'utilisation de l'expression régulière ...

EDIT:
Peut - être qu'au moment où j'ai fait ce code, je n'ai pas utilisé jsperf. Mais au final, une telle discussion est totalement inutile, la différence de performances ne vaut pas la lisibilité du code dans le monde réel, donc ma réponse est toujours valable, même si les performances diffèrent de l'approche regex.

EDIT2:
J'ai créé une bibliothèque qui vous permet de le faire en utilisant une interface fluide:

replace('.').from('okay.this.is.a.string').with(' ');

Voir https://github.com/FagnerMartinsBrack/str-replace .

str.replace(new RegExp(".","gm")," ")

Pour ce scénario simple, je recommanderais également d'utiliser les méthodes fournies avec le javascript.

Vous pouvez essayer ceci:

"okay.this.is.a.string".split(".").join("")

Salutations

J'ajoute une double barre oblique inverse au point pour le faire fonctionner. Acclamation.

var st = "okay.this.is.a.string";
var Re = new RegExp("\\.","g");
st = st.replace(Re," ");
alert(st);

Ceci est plus concis / lisible et devrait fonctionner mieux que celui publié par Fagner Brack (toLowerCase non exécuté en boucle):

String.prototype.replaceAll = function(search, replace, ignoreCase) {
  if (ignoreCase) {
    var result = [];
    var _string = this.toLowerCase();
    var _search = search.toLowerCase();
    var start = 0, match, length = _search.length;
    while ((match = _string.indexOf(_search, start)) >= 0) {
      result.push(this.slice(start, match));
      start = match + length;
    }
    result.push(this.slice(start));
  } else {
    result = this.split(search);
  }
  return result.join(replace);
}

Usage:

alert('Bananas And Bran'.replaceAll('An', '(an)'));

String.prototype.replaceAll = function(character,replaceChar){
    var word = this.valueOf();

    while(word.indexOf(character) != -1)
        word = word.replace(character,replaceChar);

    return word;
}

Voici une autre implémentation de replaceAll. J'espère que cela aide quelqu'un.

    String.prototype.replaceAll = function (stringToFind, stringToReplace) {
        if (stringToFind === stringToReplace) return this;
        var temp = this;
        var index = temp.indexOf(stringToFind);
        while (index != -1) {
            temp = temp.replace(stringToFind, stringToReplace);
            index = temp.indexOf(stringToFind);
        }
        return temp;
    };

Ensuite, vous pouvez l'utiliser:

var myText = "Je m'appelle George";
var newText = myText.replaceAll ("George", "Michael");

Exemple: je veux remplacer tous les guillemets doubles (") en guillemets simples (') Ensuite, le code sera comme ceci

var str= "\"Hello\""
var regex = new RegExp('"', 'g');
str = str.replace(regex, '\'');
console.log(str); // 'Hello'

@ scripto est un peu plus concis et sans prototype:

function strReplaceAll(s, stringToFind, stringToReplace) {
    if (stringToFind === stringToReplace) return s;
    for (let index = s.indexOf(stringToFind); index != -1; index = s.indexOf(stringToFind))
        s = s.replace(stringToFind, stringToReplace);
    return s;
}

Voici comment cela se cumule: http://jsperf.com/replace-vs-split-join-vs-replaceall/68

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

mystring.replace(new RegExp('.', "g"), ' ');

vous pouvez remplacer toutes les occurrences de n'importe quelle chaîne / caractère à l'aide de l'objet javasscript RegExp.

Voici le code,

var mystring = 'okay.this.is.a.string';

var patt = new RegExp("\\.");

while(patt.test(mystring)){

  mystring  = mystring .replace(".","");

}

var mystring = 'okay.this.is.a.string';
var myNewString = escapeHtml(mystring);

function escapeHtml(text) {
if('' !== text) {
    return text.replace(/&/g, "&")
               .replace(/&lt;/g, "<")
               .replace(/&gt;/g, ">")
               .replace(/\./g,' ')
               .replace(/&quot;/g, '"')
               .replace(/&#39/g, "'");
}