So ersetzen Sie alle Punkte in einer Zeichenfolge mithilfe von JavaScript

Ich möchte alle Vorkommen eines Punktes ( .) in einer JavaScript-Zeichenfolge ersetzen

Zum Beispiel habe ich:

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

Ich möchte bekommen : okay this is a string.

Bisher habe ich versucht:

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

Dies führt jedoch dazu, dass alle Zeichenfolgen durch Leerzeichen ersetzt werden.

Sie müssen dem entkommen, .weil es in einem regulären Ausdruck die Bedeutung eines "beliebigen Zeichens" hat.

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

Eine weitere Lösung, die leicht zu verstehen ist :)

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('.', ' '));

Schneller als Regex ...

EDIT:
Vielleicht habe ich zu der Zeit, als ich diesen Code gemacht habe, jsperf nicht benutzt. Aber am Ende ist eine solche Diskussion völlig sinnlos, der Leistungsunterschied ist die Lesbarkeit des Codes in der realen Welt nicht wert, daher ist meine Antwort immer noch gültig, auch wenn die Leistung vom Regex-Ansatz abweicht.

EDIT2:
Ich habe eine Bibliothek erstellt, mit der Sie dies über eine fließende Oberfläche tun können:

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

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

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

Für dieses einfache Szenario würde ich auch empfehlen, die in Javascript integrierten Methoden zu verwenden.

Sie könnten dies versuchen:

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

Schöne Grüße

Ich füge dem Punkt einen doppelten Backslash hinzu, damit er funktioniert. Jubeln.

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

Dies ist prägnanter / lesbarer und sollte eine bessere Leistung erbringen als die von Fagner Brack veröffentlichte (toLowerCase wird nicht in einer Schleife ausgeführt):

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

Verwendungszweck:

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

Hier ist eine weitere Implementierung von replaceAll. Hoffe es hilft jemandem.

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

Dann können Sie es verwenden:

var myText = "Mein Name ist George";
var newText = myText.replaceAll ("George", "Michael");

Beispiel: Ich möchte alle doppelten Anführungszeichen (") durch einfache Anführungszeichen (') ersetzen. Dann sieht der Code so aus

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

@ scripto ist etwas prägnanter und ohne 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;
}

So stapelt es sich: 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"), ' ');

Sie können alle Vorkommen von Zeichenfolgen / Zeichen mithilfe des RegExp-Javasscript-Objekts ersetzen.

Hier ist der 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, "'");
}