Comment remplacer plusieurs espaces blancs par un seul espace blanc ?

Question

Disons que j'ai une chaîne de caractères telle que :

"Hello     how are   you           doing?"

Je voudrais une fonction qui transforme plusieurs espaces en un seul espace.

J'obtiendrais donc :

"Hello how are you doing?"

Je sais que je pourrais utiliser des expressions rationnelles ou appeler

string s = "Hello     how are   you           doing?".replace("  "," ");

Mais je devrais l'appeler plusieurs fois pour m'assurer que tous les espaces blancs séquentiels sont remplacés par un seul.

Existe-t-il déjà une méthode intégrée pour cela ?

Answer 1

string cleanedString = System.Text.RegularExpressions.Regex.Replace(dirtyString,@"\s+"," ");

Answer 2

Cette question n'est pas aussi simple que d'autres affiches l'ont fait croire (et que je le pensais à l'origine) - parce que la question n'est pas aussi précise qu'elle devrait l'être.

Il y a une différence entre "espace" et "espace blanc". Si vous sólo signifient des espaces, vous devez alors utiliser une expression rationnelle du type " {2,}" . Si vous voulez dire tous les espaces blancs, c'est une autre affaire. Devrait tous les espaces blancs sont-ils convertis en espaces ? Qu'advient-il des espaces au début et à la fin ?

Pour le benchmark ci-dessous, j'ai supposé que vous ne vous intéressiez qu'aux espaces et que vous ne vouliez rien faire pour les espaces simples, même au début et à la fin.

Notez que l'exactitude est presque toujours plus importante que la performance. Le fait que la solution Split/Join supprime tout espace blanc en début ou en fin de texte (même s'il ne s'agit que d'espaces simples) est incorrect au regard des exigences que vous avez spécifiées (qui peuvent être incomplètes, bien entendu).

L'indice de référence utilise MiniBench .

using System;
using System.Text.RegularExpressions;
using MiniBench;

internal class Program
{
    public static void Main(string[] args)
    {

        int size = int.Parse(args[0]);
        int gapBetweenExtraSpaces = int.Parse(args[1]);

        char[] chars = new char[size];
        for (int i=0; i < size/2; i += 2)
        {
            // Make sure there actually *is* something to do
            chars[i*2] = (i % gapBetweenExtraSpaces == 1) ? ' ' : 'x';
            chars[i*2 + 1] = ' ';
        }
        // Just to make sure we don't have a \0 at the end
        // for odd sizes
        chars[chars.Length-1] = 'y';

        string bigString = new string(chars);
        // Assume that one form works :)
        string normalized = NormalizeWithSplitAndJoin(bigString);

        var suite = new TestSuite<string, string>("Normalize")
            .Plus(NormalizeWithSplitAndJoin)
            .Plus(NormalizeWithRegex)
            .RunTests(bigString, normalized);

        suite.Display(ResultColumns.All, suite.FindBest());
    }

    private static readonly Regex MultipleSpaces = 
        new Regex(@" {2,}", RegexOptions.Compiled);

    static string NormalizeWithRegex(string input)
    {
        return MultipleSpaces.Replace(input, " ");
    }

    // Guessing as the post doesn't specify what to use
    private static readonly char[] Whitespace =
        new char[] { ' ' };

    static string NormalizeWithSplitAndJoin(string input)
    {
        string[] split = input.Split
            (Whitespace, StringSplitOptions.RemoveEmptyEntries);
        return string.Join(" ", split);
    }
}

Quelques essais :

c:\Users\Jon\Test>test 1000 50
============ Normalize ============
NormalizeWithSplitAndJoin  1159091 0:30.258 22.93
NormalizeWithRegex        26378882 0:30.025  1.00

c:\Users\Jon\Test>test 1000 5
============ Normalize ============
NormalizeWithSplitAndJoin  947540 0:30.013 1.07
NormalizeWithRegex        1003862 0:29.610 1.00

c:\Users\Jon\Test>test 1000 1001
============ Normalize ============
NormalizeWithSplitAndJoin  1156299 0:29.898 21.99
NormalizeWithRegex        23243802 0:27.335  1.00

Ici, le premier chiffre est le nombre d'itérations, le deuxième est le temps nécessaire et le troisième est un score échelonné, 1,0 étant le meilleur.

Cela montre qu'au moins dans certains cas (y compris celui-ci), une expression régulière peut surpassent la solution du fractionnement et de la jonction, parfois avec une marge très importante.

Cependant, si vous passez à une exigence de "tous les espaces", alors Split/Join fait semblent gagner. Comme souvent, le diable se cache dans les détails...

Answer 3

La solution la plus simple serait d'utiliser un expresso régulier. Si vous écrivez l'expression régulière de la bonne manière, vous n'aurez pas besoin d'appels multiples.

Remplacez-la par ceci :

string s = System.Text.RegularExpressions.Regex.Replace(s, @"\s{2,}", " ");

Answer 4

Bien que les réponses existantes soient satisfaisantes, j'aimerais souligner une approche qui a fait ses preuves. ne travail :

public static string DontUseThisToCollapseSpaces(string text)
{
    while (text.IndexOf("  ") != -1)
    {
        text = text.Replace("  ", " ");
    }
    return text;
}

Cette opération peut se répéter à l'infini. Quelqu'un peut-il deviner pourquoi ? (Je n'ai découvert cette question que lorsqu'elle a été posée dans un groupe de discussion il y a quelques années... quelqu'un l'a en fait rencontrée comme un problème).

Answer 5

Comme nous l'avons déjà souligné, il est facile de le faire à l'aide d'une expression régulière. J'ajouterai simplement que vous voudrez peut-être ajouter un .trim() à cela pour vous débarrasser des espaces blancs de début et de fin.