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

426

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.

Omar Abid
fuente
8
La respuesta de aefxx es correcta, pero al igual que para su información, el carácter de punto en una expresión regular significa que coincide con todo , por lo tanto, todo es un espacio. Escapar con la barra invertida significa coincidencia en los períodos.
swilliams
Gracias por el consejo. He tenido algunos momentos de AHA (cuando construyo la aplicación) con Regex. Realmente lo odio _ , ¿tienes algún buen tutorial genial?
Omar Abid
rubular.com es lo que estás buscando
LanguagesNamedAfterCofee
1
No uses una expresión regular para algo tan trivial.
Steven Lu
Desafortunadamente, no parece que una expresión no regular puede permitir el reemplazo de una cadena varias veces.
Steven Lu

Respuestas:

777

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

mystring = mystring.replace(/\./g,' ')
aefxx
fuente
25
solo para aclarar, el \ escapa caracteres especiales en expresiones regulares, como el. en este caso
realgt
parece sed .. de alguna manera .. :)
Paschalis
en reagukar expresión el punto. significa todo, ¡esta es la solución correcta!
Benjamin Fuentes
1
@Kingalione ¿Qué es exactamente lo que no funciona? ¿Podrías dar más detalles?
aefxx
1
@Webwoman Para eso se usa el gmodificador al final de la expresión. Piense en ello como (g) lobalmente.
aefxx
302

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

var newstring = mystring.split('.').join(' ');
Umesh Patil
fuente
25
@HaggleLad porque no necesitas
meterte
55
¿No es esto mucho más lento que la expresión regular?
Jasper Kennis
1
@Jasper, según tengo entendido, en realidad es más rápido en la mayoría de los navegadores, aunque no lo he comparado yo mismo.
Andrew
99
@BetoFrega Nada como algunos datos empíricos para exponer su caso :). Gracias por proporcionar el enlace!
testing123
3
Si usa RegExp, desea almacenar la expresión regular en una variable separada fuera del bucle. Compilar / interpretar una expresión regular lleva algo de tiempo, pero una vez que se compila, se puede usar bastante rápido. Pruebe estas pruebas que hice: jsperf.com/replace-vs-split-join-vs-replaceall/23
sanderd17
53
/**
 * 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 .

Fagner Brack
fuente
1
Muy útil. FYI: Hay caracteres falsos después del punto y coma en la declaración de alerta.
Patrick
¿Qué quieres decir con "personaje pícaro"?
Fagner Brack
1
Se refiere a la entidad & # 8203; dos veces, que es el carácter Unicode 'ZERO WIDTH SPACE' (U + 200B). Más información en fileformat.info/info/unicode/char/200b/index.htm
Cœur
@FagnerBrack Probablemente deberías str.toLowerCase()sacar el ciclo por razones de rendimiento. Además, manipular la cadena que está buscando probablemente sea menos que óptima.
Publiqué
@sstur Supongo que es necesario volver a poner en minúscula la cadena nuevamente después de la manipulación. ¿Manipular la cadena que estoy buscando es una diferencia considerable en el rendimiento? Supongo que la legibilidad supera los beneficios (no probados).
Fagner Brack
22
str.replace(new RegExp(".","gm")," ")
macemers
fuente
1
Funcionó muy bien para reemplazar función =)
afreeland
15

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

Víctor
fuente
6

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);
kittichart
fuente
4

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)'));
sstur
fuente
1
En realidad, parece que RegEx escapó funciona mejor que indexOf! No suena bien, pero JSPerf indica que es mucho más rápido: jsperf.com/replaceall-indexof-vs-regex
sstur
Quizás cuando hice ese código no usé jsperf. Pero al final, tal discusión no tiene ningún 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.
Fagner Brack
2
String.prototype.replaceAll = function(character,replaceChar){
    var word = this.valueOf();

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

    return word;
}
Joel
fuente
3
¿Esto no se queda bloqueado en un bucle infinito si le dan algo así como: replaceAll('&', '&')? (Es cierto que no es un caso en la pregunta del OP)
Anentropic
Pero "& amp;" contiene un &modo de que el bucle nunca se quede sin cosas para reemplazar (y la cadena sigue creciendo). Lo intenté hace un momento y bloqueó mi navegador ...
Anentropic
2

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

scripto
fuente
1
Esto no maneja la búsqueda / reemplazo entre mayúsculas y minúsculas. Por lo que es funcionalmente equivalente a:string.split(stringToFind).join(stringToReplace)
sstur
0

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'
Neel Kamal
fuente
0

@ 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

A
fuente
0
String.prototype.replaceAll = function (needle, replacement) {
    return this.replace(new RegExp(needle, 'g'), replacement);
};
Danon
fuente
0
mystring.replace(new RegExp('.', "g"), ' ');
Idan
fuente
-1

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

}
Rakesh Chaudhari
fuente
-5
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, "'");
} 
Neha
fuente
Para escapar de HTML, usecreateTextNode
Downgoat