Comment remplacer plusieurs espaces par un seul espace en C #?

Comment remplacer plusieurs espaces dans une chaîne par un seul espace en C #?

Exemple:

1 2 3  4    5

serait:

1 2 3 4 5

string sentence = "This is a sentence with multiple    spaces";
RegexOptions options = RegexOptions.None;
Regex regex = new Regex("[ ]{2,}", options);     
sentence = regex.Replace(sentence, " ");

J'aime utiliser:

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

Puisqu'il attrapera des courses de n'importe quel genre d'espace blanc (par exemple des tabulations, des nouvelles lignes, etc.) et les remplacera par un espace simple.

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

Je pense que la réponse de Matt est la meilleure, mais je ne pense pas que ce soit tout à fait juste. Si vous souhaitez remplacer les sauts de ligne, vous devez utiliser:

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

Une autre approche qui utilise LINQ:

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

C'est beaucoup plus simple que ça:

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

Regex peut être assez lent, même avec des tâches simples. Cela crée une méthode d'extension qui peut être utilisée à partir de n'importe quel 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();
        }
    }

Il serait utilisé comme tel:

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

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

Pour ceux qui n'aiment pas Regex, voici une méthode qui utilise 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();
    }

Dans mes tests, cette méthode était en moyenne 16 fois plus rapide avec un très grand ensemble de chaînes de petite à moyenne taille, par rapport à une Regex compilée statique. Comparé à une regex non compilée ou non statique, cela devrait être encore plus rapide.

Gardez à l'esprit qu'il ne supprime pas les espaces de début ou de fin, mais uniquement les occurrences multiples de ceux-ci.

Vous pouvez simplement le faire en une seule solution!

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

Vous pouvez choisir d'autres parenthèses (ou même d'autres caractères) si vous le souhaitez.

Il s'agit d'une version plus courte, qui ne doit être utilisée que si vous ne le faites qu'une seule fois, car elle crée une nouvelle instance de la Regex classe à chaque appel.

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

Si vous n'êtes pas trop familier avec les expressions régulières, voici une courte explication:

le {2,} fait que l'expression régulière recherche le caractère qui le précède et trouve des sous-chaînes entre 2 et un nombre illimité de fois.
Le .Replace(temp, " ")remplace toutes les correspondances dans la chaîne de caractères par un espace.

Si vous souhaitez l'utiliser plusieurs fois, voici une meilleure option, car elle crée l'IL regex au moment de la compilation:

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

pas de Regex, pas de Linq ... supprime les espaces de début et de fin ainsi que la réduction de tous les segments d'espace intégrés dans un seul espace

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

résultat: "0 1 2 3 4 5"

Consolider d'autres réponses, par Joel, et, espérons-le, s'améliorer légèrement au fur et à mesure:

Vous pouvez le faire avec Regex.Replace():

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

Ou avec 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 (" ");

Je viens d'écrire une nouvelle Joinque j'aime, alors j'ai pensé que je répondrais de nouveau avec:

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

Une des choses intéressantes à ce sujet est qu'il fonctionne avec des collections qui ne sont pas des chaînes, en appelant ToString () sur les éléments. L'utilisation est toujours la même:

//...

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

      // Mysample string
            string str ="hi you           are          a demo";

            //Split the words based on white sapce
            var demo= str .Split(' ').Where(s => !string.IsNullOrWhiteSpace(s));

            //Join the values back and add a single space in between
                    str = string.Join(" ", demo);

//output: string str ="hi you are a demo";

Je sais que c'est assez vieux, mais je l'ai rencontré en essayant d'accomplir presque la même chose. Trouvé cette solution dans RegEx Buddy. Ce modèle remplacera tous les espaces doubles par des espaces simples et coupera également les espaces de début et de fin.

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

C'est un peu difficile à lire car nous avons affaire à un espace vide, donc ici, c'est à nouveau avec les "espaces" remplacés par un "_".

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

La construction "(? M:" active l'option "multiligne". J'aime généralement inclure toutes les options que je peux dans le motif lui-même afin qu'il soit plus autonome.

De nombreuses réponses fournissent la bonne sortie, mais pour ceux qui recherchent les meilleures performances, j'ai amélioré la réponse de Nolanar (qui était la meilleure réponse pour les performances) d'environ 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();
    }

}

Je peux supprimer les espaces blancs avec ceci

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

Utilisez le modèle regex

    [ ]+    #only space

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

essayez cette méthode

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

utilisez-le comme ceci:

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

Voici une légère modification de la réponse originale de Nolonar .

Pour vérifier si le caractère n'est pas seulement un espace, mais n'importe quel espace, utilisez ceci:

Il remplacera tout caractère d'espaces multiples par un seul espace.

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

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

Vieille école:

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

Sans utiliser d'expressions régulières:

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

OK à utiliser sur les chaînes courtes, mais fonctionne mal sur les chaînes longues avec beaucoup d'espace.

Mélange de StringBuilder et Enumerable.Aggregate () comme méthode d'extension pour les chaînes:

using System;
using System.Linq;
using System.Text;

public static class StringExtension
{
    public static string StripSpaces(this string s)
    {
        return s.Aggregate(new StringBuilder(), (acc, c) =>
        {
            if (c != ' ' || acc.Length > 0 && acc[acc.Length-1] != ' ')
                acc.Append(c);

            return acc;
        }).ToString();
    }

    public static void Main()
    {
        Console.WriteLine("\"" + StringExtension.StripSpaces("1   Hello       World  2   ") + "\"");
    }
}

Contribution:

"1   Hello       World  2   "

Production:

"1 Hello World 2 "