Cómo reemplazar todos los puntos en una cadena usando JavaScript

Quiero reemplazar todas las apariciones de un punto ( .) en una cadena de JavaScript

Por ejemplo, tengo:

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

Quiero llegar: okay this is a string.

Hasta ahora lo intenté:

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

pero esto termina con toda la cadena reemplazada por espacios.

Debe escapar .porque tiene el significado de "un carácter arbitrario" en una expresión regular.

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

Una solución más que es fácil de entender :)

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

Más rápido que usar expresiones regulares ...

EDITAR:
Quizás en el momento en que hice este código no usé jsperf. Pero al final, tal discusión no tiene sentido, la diferencia de rendimiento no vale la legibilidad del código en el mundo real, por lo que mi respuesta sigue siendo válida, incluso si el rendimiento difiere del enfoque de expresiones regulares.

EDIT2:
he creado una lib que te permite hacer esto usando una interfaz fluida:

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

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

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

Para este escenario simple, también recomendaría usar los métodos que vienen incorporados en javascript.

Podrías probar esto:

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

Saludos

Agrego una barra diagonal inversa doble al punto para que funcione. Animar.

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

Esto es más conciso / legible y debería funcionar mejor que el publicado por Fagner Brack (toLowerCase no realizado en bucle):

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

Uso:

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

Aquí hay otra implementación de replaceAll. Espero que ayude a alguien.

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

Entonces puedes usarlo:

var myText = "Mi nombre es George";
var newText = myText.replaceAll ("George", "Michael");

Ejemplo: quiero reemplazar todas las comillas dobles (") en comillas simples (') Entonces el código será así

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

@ scripto es un poco más conciso y sin 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;
}

Así es como se acumula: 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"), ' ');

Puede reemplazar todas las apariciones de cualquier cadena / carácter utilizando el objeto RegExp javasscript.

Aquí está el código

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