separar - ¿Cómo puedo reemplazar múltiples espacios con un solo espacio en C#?

separar por espacios c#

Question

¿Cómo puedo reemplazar múltiples espacios en una cadena con solo un espacio en C #?

Ejemplo:

1 2 3  4    5

sería:

1 2 3 4 5

Answer 1

Acabo de escribir una nueva Join que me gusta, así que pensé que volvería a responder con ella:

public static string Join<T>(this IEnumerable<T> source, string separator)
{
    return string.Join(separator, source.Select(e => e.ToString()).ToArray());
}

Una de las cosas interesantes de esto es que funciona con colecciones que no son cadenas, llamando a ToString () en los elementos. El uso sigue siendo el mismo:

//...

string s = "     1  2    4 5".Split (
    " ".ToCharArray(), 
    StringSplitOptions.RemoveEmptyEntries
    ).Join (" ");

Answer 2

Consolodando otras respuestas, por Joel, y con suerte mejorando ligeramente a medida que avanzo:

Puedes hacer esto con Regex.Replace() :

string s = Regex.Replace (
    "   1  2    4 5", 
    @"[ ]{2,}", 
    " "
    );

O con String.Split() :

static class StringExtensions
{
    public static string Join(this IList<string> value, string separator)
    {
        return string.Join(separator, value.ToArray());
    }
}

//...

string s = "     1  2    4 5".Split (
    " ".ToCharArray(), 
    StringSplitOptions.RemoveEmptyEntries
    ).Join (" ");

Answer 3

Creo que la respuesta de Matt es la mejor, pero no creo que sea la correcta. Si desea reemplazar las nuevas líneas, debe utilizar:

myString = Regex.Replace(myString, @"/s+", " ", RegexOptions.Multiline);

Answer 4

Es mucho más simple que todo eso:

while(str.Contains("  ")) str = str.Replace("  ", " ");

Answer 5

Esta es una versión más corta, que solo debe usarse si solo haces esto una vez, ya que crea una nueva instancia de la clase Regex cada vez que se llama.

temp = new Regex(" {2,}").Replace(temp, " "); 

Si no estás familiarizado con las expresiones regulares, aquí tienes una breve explicación:

El {2,} hace que la expresión regular busque el carácter que lo precede, y encuentra subcadenas entre 2 y tiempos ilimitados.
.Replace(temp, " ") reemplaza todas las coincidencias en la cadena temp con un espacio.

Si desea usar esto varias veces, esta es una mejor opción, ya que crea el regex IL en tiempo de compilación:

Regex singleSpacify = new Regex(" {2,}", RegexOptions.Compiled);
temp = singleSpacify.Replace(temp, " ");

Answer 6

Me gusta usar:

myString = Regex.Replace(myString, @"/s+", " ");

Ya que capturará ejecuciones de cualquier tipo de espacio en blanco (por ejemplo, pestañas, nuevas líneas, etc.) y las reemplazará con un solo espacio.

Answer 7

Muchas respuestas están proporcionando la salida correcta, pero para aquellos que buscan las mejores actuaciones, mejoré la respuesta de Nolanar (que fue la mejor respuesta para el rendimiento) en aproximadamente un 10%.

public static string MergeSpaces(this string str)
{

    if (str == null)
    {
        return null;
    }
    else
    {
        StringBuilder stringBuilder = new StringBuilder(str.Length);

        int i = 0;
        foreach (char c in str)
        {
            if (c != '' '' || i == 0 || str[i - 1] != '' '')
                stringBuilder.Append(c);
            i++;
        }
        return stringBuilder.ToString();
    }

}

Answer 8

Otro enfoque que utiliza LINQ:

 var list = str.Split('' '').Where(s => !string.IsNullOrWhiteSpace(s));
 str = string.Join(" ", list);

Answer 9

Para aquellos que no les gusta Regex , aquí hay un método que utiliza StringBuilder :

    public static string FilterWhiteSpaces(string input)
    {
        if (input == null)
            return string.Empty;

        StringBuilder stringBuilder = new StringBuilder(input.Length);
        for (int i = 0; i < input.Length; i++)
        {
            char c = input[i];
            if (i == 0 || c != '' '' || (c == '' '' && input[i - 1] != '' ''))
                stringBuilder.Append(c);
        }
        return stringBuilder.ToString();
    }

En mis pruebas, este método fue 16 veces más rápido en promedio con un conjunto muy grande de cuerdas de tamaño pequeño a mediano, en comparación con un Regex compilado estático. En comparación con un Regex no compilado o no estático, esto debería ser incluso más rápido.

Tenga en cuenta que no elimina los espacios iniciales o finales, solo varias apariciones de los mismos.

Answer 10

Puedo eliminar espacios en blanco con esto

while word.contains("  ")  //double space
   word = word.Replace("  "," "); //replace double space by single space.
word = word.trim(); //to remove single whitespces from start & end.

Answer 11

Regex puede ser bastante lento incluso con tareas simples. Esto crea un método de extensión que puede usarse fuera de cualquier string .

    public static class StringExtension
    {
        public static String ReduceWhitespace(this String value)
        {
            var newString = new StringBuilder();
            bool previousIsWhitespace = false;
            for (int i = 0; i < value.Length; i++)
            {
                if (Char.IsWhiteSpace(value[i]))
                {
                    if (previousIsWhitespace)
                    {
                        continue;
                    }

                    previousIsWhitespace = true;
                }
                else
                {
                    previousIsWhitespace = false;
                }

                newString.Append(value[i]);
            }

            return newString.ToString();
        }
    }

Sería utilizado como tal:

string testValue = "This contains     too          much  whitespace."
testValue = testValue.ReduceWhitespace();
// testValue = "This contains too much whitespace."

Answer 12

Sé que esto es bastante viejo, pero lo encontré mientras intentaba lograr casi lo mismo. Encontré esta solución en RegEx Buddy. Este patrón reemplazará todos los espacios dobles con espacios simples y también recortará los espacios iniciales y finales.

pattern: (?m:^ +| +$|( ){2,})
replacement: $1

Es un poco difícil de leer ya que estamos tratando con un espacio vacío, así que aquí está de nuevo con los "espacios" reemplazados con una "_".

pattern: (?m:^_+|_+$|(_){2,})  <-- don''t use this, just for illustration.

La construcción "(? M:" habilita la opción "multilínea". En general, me gusta incluir todas las opciones que pueda dentro del propio patrón para que sea más independiente.

Answer 13

Simplemente puede hacer esto en una solución de línea!

string s = "welcome to  london";
s.Replace(" ", "()").Replace(")(", "").Replace("()", " ");

Puede elegir otros corchetes (o incluso otros caracteres) si lo desea.

Answer 14

Sin usar expresiones regulares:

while (myString.IndexOf("  ", StringComparison.CurrentCulture) != -1)
{
    myString = myString.Replace("  ", " ");
}

Está bien para usar en cadenas cortas, pero tendrá un mal desempeño en cadenas largas con muchos espacios.

Answer 15

Usa el patrón regex

    [ ]+    #only space

   var text = Regex.Replace(inputString, @"[ ]+", " ");

Answer 16

Vieja escuela:

string oldText = "   1 2  3   4    5     ";
string newText = oldText
                    .Replace("  ", " " + (char)22 )
                    .Replace( (char)22 + " ", "" )
                    .Replace( (char)22 + "", "" );

Assert.That( newText, Is.EqualTo( " 1 2 3 4 5 " ) );

Answer 17

no Regex, no Linq ... elimina los espacios iniciales y finales, así como la reducción de cualquier segmento de espacio múltiple incrustado a un espacio

string myString = "   0 1 2  3   4               5  ";
myString = string.Join(" ", myString.Split(new char[] { '' '' }, 
StringSplitOptions.RemoveEmptyEntries));

resultado: "0 1 2 3 4 5"

Answer 18

prueba este método

private string removeNestedWhitespaces(char[] st)
{
    StringBuilder sb = new StringBuilder();
    int indx = 0, length = st.Length;
    while (indx < length)
    {
        sb.Append(st[indx]);
        indx++;
        while (indx < length && st[indx] == '' '')
            indx++;
        if(sb.Length > 1  && sb[0] != '' '')
            sb.Append('' '');
    }
    return sb.ToString();
}

utilízalo así:

string test = removeNestedWhitespaces("1 2 3  4    5".toCharArray());

Answer 19

RegexOptions options = RegexOptions.None;
Regex regex = new Regex("[ ]{2,}", options);     
tempo = regex.Replace(tempo, " ");

Answer 20

myString = Regex.Replace(myString, " {2,}", " ");

Answer 21

string xyz = "1   2   3   4   5";
xyz = string.Join( " ", xyz.Split( new char[] { '' '' }, StringSplitOptions.RemoveEmptyEntries ));