Birden çok beyaz alanı tek bir boşlukla değiştirme

Diyelim ki benim gibi bir dizem var:

"Hello     how are   you           doing?"

Birden fazla alanı tek bir alana dönüştüren bir işlev istiyorum.

Böylece alırdım:

"Hello how are you doing?"

Normal ifade kullanabileceğimi veya arayabileceğimi biliyorum

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

Ancak, tüm sıralı boşlukların yalnızca bir boşlukla değiştirildiğinden emin olmak için bunu birden çok kez aramam gerekirdi.

Bunun için zaten yerleşik bir yöntem var mı?

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

Bu soru, diğer afişlerin ortaya koyduğu kadar basit değil (ve aslında olduğuna inandığım gibi) - çünkü soru olması gerektiği kadar kesin değil.

"Boşluk" ve "boşluk" arasında bir fark vardır. Eğer varsa sadece boşluk anlamına, o zaman bir düzenli ifade kullanmalıdır " {2,}". Herhangi bir boşluktan bahsediyorsanız, bu farklı bir konudur. Should tüm boşluk alanlara dönüştürülebilir? Başlangıçta ve sonda uzaya ne olmalı?

Aşağıdaki kıyaslama için, yalnızca boşlukları önemsediğinizi ve başlangıçta ve sonda bile tek boşluklara hiçbir şey yapmak istemediğinizi varsaydım.

Doğruluğun neredeyse her zaman performanstan daha önemli olduğunu unutmayın. Split / Join çözümünün baştaki / sondaki beyaz boşlukları (tek boşluklar bile) kaldırması gerçeği, belirtilen gereksinimlerinize göre yanlıştır (tabii ki eksik olabilir).

Kıyaslama MiniBench kullanıyor .

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

Birkaç test çalışması:

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

Buradaki ilk sayı yineleme sayısı, ikincisi geçen süre ve üçüncüsü 1.0 en iyi olan ölçeklendirilmiş bir puandır.

Yani gösterileri ki en azından (bu dahil) bazı durumlarda normal bir ifade olabilir Böl daha iyi performans / çok önemli bir farkla bazen çözüm katılın.

Ancak, bir "tüm boşluk" gereksinimine geçerseniz, Böl / Birleştir kazanmış gibi görünür. Çoğu zaman olduğu gibi, şeytan ayrıntıda gizlidir ...

Normal bir espresso, en kolay yol olacaktır. Normal ifadeyi doğru şekilde yazarsanız, birden fazla çağrı yapmanız gerekmez.

Şununla değiştirin:

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

Varolan cevaplar ince olsa da, ben bir yaklaşım işaret etmek istiyorum değil iş:

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

Bu sonsuza kadar dönebilir. Nedenini tahmin etmek isteyen var mı? (Buna sadece birkaç yıl önce bir haber grubu sorusu olarak sorulduğunda karşılaştım ... biri aslında bir sorun olarak karşılaştı.)

Daha önce de belirtildiği gibi, bu, normal bir ifade ile kolayca yapılır. Baştaki / sondaki boşluktan kurtulmak için buna bir .trim () eklemek isteyebileceğinizi ekleyeceğim.

İşte çalıştığım Çözüm. RegEx ve String.Split olmadan.

public static string TrimWhiteSpace(this string Value)
{
    StringBuilder sbOut = new StringBuilder();
    if (!string.IsNullOrEmpty(Value))
    {
        bool IsWhiteSpace = false;
        for (int i = 0; i < Value.Length; i++)
        {
            if (char.IsWhiteSpace(Value[i])) //Comparion with WhiteSpace
            {
                if (!IsWhiteSpace) //Comparison with previous Char
                {
                    sbOut.Append(Value[i]);
                    IsWhiteSpace = true;
                }
            }
            else
            {
                IsWhiteSpace = false;
                sbOut.Append(Value[i]);
            }
        }
    }
    return sbOut.ToString();
}

Böylece yapabilirsiniz:

string cleanedString = dirtyString.TrimWhiteSpace();

Felipe Machado tarafından hızlı bir ekstra boşluk temizleyici. (Çoklu alan kaldırma için RW tarafından değiştirildi)

static string DuplicateWhiteSpaceRemover(string str)
{
    var len = str.Length;
    var src = str.ToCharArray();
    int dstIdx = 0;
    bool lastWasWS = false; //Added line
    for (int i = 0; i < len; i++)
    {
        var ch = src[i];
        switch (ch)
        {
            case '\u0020': //SPACE
            case '\u00A0': //NO-BREAK SPACE
            case '\u1680': //OGHAM SPACE MARK
            case '\u2000': // EN QUAD
            case '\u2001': //EM QUAD
            case '\u2002': //EN SPACE
            case '\u2003': //EM SPACE
            case '\u2004': //THREE-PER-EM SPACE
            case '\u2005': //FOUR-PER-EM SPACE
            case '\u2006': //SIX-PER-EM SPACE
            case '\u2007': //FIGURE SPACE
            case '\u2008': //PUNCTUATION SPACE
            case '\u2009': //THIN SPACE
            case '\u200A': //HAIR SPACE
            case '\u202F': //NARROW NO-BREAK SPACE
            case '\u205F': //MEDIUM MATHEMATICAL SPACE
            case '\u3000': //IDEOGRAPHIC SPACE
            case '\u2028': //LINE SEPARATOR
            case '\u2029': //PARAGRAPH SEPARATOR
            case '\u0009': //[ASCII Tab]
            case '\u000A': //[ASCII Line Feed]
            case '\u000B': //[ASCII Vertical Tab]
            case '\u000C': //[ASCII Form Feed]
            case '\u000D': //[ASCII Carriage Return]
            case '\u0085': //NEXT LINE
                if (lastWasWS == false) //Added line
                {
                    src[dstIdx++] = ' '; // Updated by Ryan
                    lastWasWS = true; //Added line
                }
                continue;
            default:
                lastWasWS = false; //Added line 
                src[dstIdx++] = ch;
                break;
        }
    }
    return new string(src, 0, dstIdx);
}

Kriterler ...

|                           | Time  |   TEST 1    |   TEST 2    |   TEST 3    |   TEST 4    |   TEST 5    |
| Function Name             |(ticks)| dup. spaces | spaces+tabs | spaces+CR/LF| " " -> " "  | " " -> " " |
|---------------------------|-------|-------------|-------------|-------------|-------------|-------------|
| SwitchStmtBuildSpaceOnly  |   5.2 |    PASS     |    FAIL     |    FAIL     |    PASS     |    PASS     |
| InPlaceCharArraySpaceOnly |   5.6 |    PASS     |    FAIL     |    FAIL     |    PASS     |    PASS     |
| DuplicateWhiteSpaceRemover|   7.0 |    PASS     |    PASS     |    PASS     |    PASS     |    PASS     |
| SingleSpacedTrim          |  11.8 |    PASS     |    PASS     |    PASS     |    FAIL     |    FAIL     |
| Fubo(StringBuilder)       |    13 |    PASS     |    FAIL     |    FAIL     |    PASS     |    PASS     |
| User214147                |    19 |    PASS     |    PASS     |    PASS     |    FAIL     |    FAIL     | 
| RegExWithCompile          |    28 |    PASS     |    FAIL     |    FAIL     |    PASS     |    PASS     |
| SwitchStmtBuild           |    34 |    PASS     |    FAIL     |    FAIL     |    PASS     |    PASS     |
| SplitAndJoinOnSpace       |    55 |    PASS     |    FAIL     |    FAIL     |    FAIL     |    FAIL     |
| RegExNoCompile            |   120 |    PASS     |    PASS     |    PASS     |    PASS     |    PASS     |
| RegExBrandon              |   137 |    PASS     |    FAIL     |    PASS     |    PASS     |    PASS     |

Karşılaştırma notları: Yayın Modu, hata ayıklayıcı takılı değil, i7 işlemci, ortalama 4 çalıştırma, yalnızca kısa diziler test edildi

SwitchStmtBuildSpaceOnly Felipe Machado 2015 tarafından ve Sunsetquest tarafından değiştirildi

InPlaceCharArraySpaceOnly tarafından Felipe Machado 2015 ve değiştirilen Sunsetquest

SwitchStmtBuild Felipe Machado 2015 tarafından ve Sunsetquest tarafından değiştirildi

SwitchStmtBuild2 Felipe Machado 2015 tarafından hazırlanmıştır ve Sunsetquest tarafından değiştirilmiştir

SingleSpacedTrim David S 2013 tarafından

Fubo (StringBuilder) fubo 2014 tarafından

SplitAndJoinOnSpace Jon Skeet tarafından 2009

RegExWithCompile Jon Skeet tarafından 2009

User214147 tarafından user214147

RegExBrandon, Brandon tarafından

RegExNoCompile Tim Hoolihan tarafından

Karşılaştırma kodu Github'da

Kullandığımı paylaşıyorum, çünkü farklı bir şey bulduğum görülüyor. Bunu bir süredir kullanıyorum ve benim için yeterince hızlı. Diğerlerine karşı nasıl yığıldığından emin değilim. Bunu sınırlandırılmış bir dosya yazıcısında kullanıyorum ve büyük veri tablolarını her seferinde bir alan üzerinden çalıştırıyorum.

    public static string NormalizeWhiteSpace(string S)
    {
        string s = S.Trim();
        bool iswhite = false;
        int iwhite;
        int sLength = s.Length;
        StringBuilder sb = new StringBuilder(sLength);
        foreach(char c in s.ToCharArray())
        {
            if(Char.IsWhiteSpace(c))
            {
                if (iswhite)
                {
                    //Continuing whitespace ignore it.
                    continue;
                }
                else
                {
                    //New WhiteSpace

                    //Replace whitespace with a single space.
                    sb.Append(" ");
                    //Set iswhite to True and any following whitespace will be ignored
                    iswhite = true;
                }  
            }
            else
            {
                sb.Append(c.ToString());
                //reset iswhitespace to false
                iswhite = false;
            }
        }
        return sb.ToString();
    }

Jon Skeet'in gönderdiği test programını kullanarak, daha hızlı çalışması için elle yazılmış bir döngü alıp alamayacağımı görmeye çalıştım.
NormalizeWithSplitAndJoin'i her seferinde yenebilirim, ancak NormalizeWithRegex'i yalnızca 1000, 5 girdilerle geçebilirim.

static string NormalizeWithLoop(string input)
{
    StringBuilder output = new StringBuilder(input.Length);

    char lastChar = '*';  // anything other then space 
    for (int i = 0; i < input.Length; i++)
    {
        char thisChar = input[i];
        if (!(lastChar == ' ' && thisChar == ' '))
            output.Append(thisChar);

        lastChar = thisChar;
    }

    return output.ToString();
}

Jitter'in ürettiği makine koduna bakmadım, ancak problemin StringBuilder.Append () çağrısının harcadığı zamandır ve çok daha iyisini yapmak için güvenli olmayan kodun kullanılması gerekir.

Yani Regex.Replace () çok hızlı ve yenmesi zor !!

VB.NET

Linha.Split(" ").ToList().Where(Function(x) x <> " ").ToArray

C #

Linha.Split(" ").ToList().Where(x => x != " ").ToArray();

LINQ = D'nin gücünün tadını çıkarın

Regex regex = new Regex(@"\W+");
string outputString = regex.Replace(inputString, " ");

En küçük çözüm:

var regExp = / \ s + / g, newString = oldString.replace (regExp, '');

Bunu deneyebilirsiniz:

    /// <summary>
    /// Remove all extra spaces and tabs between words in the specified string!
    /// </summary>
    /// <param name="str">The specified string.</param>
    public static string RemoveExtraSpaces(string str)
    {
        str = str.Trim();
        StringBuilder sb = new StringBuilder();
        bool space = false;
        foreach (char c in str)
        {
            if (char.IsWhiteSpace(c) || c == (char)9) { space = true; }
            else { if (space) { sb.Append(' '); }; sb.Append(c); space = false; };
        }
        return sb.ToString();
    }

Değiştirme grupları, birden çok beyaz boşluk karakterinin aynı tek karakterle değiştirilmesini çözümleyen impler yaklaşımı sağlar :

    public static void WhiteSpaceReduce()
    {
        string t1 = "a b   c d";
        string t2 = "a b\n\nc\nd";

        Regex whiteReduce = new Regex(@"(?<firstWS>\s)(?<repeatedWS>\k<firstWS>+)");
        Console.WriteLine("{0}", t1);
        //Console.WriteLine("{0}", whiteReduce.Replace(t1, x => x.Value.Substring(0, 1))); 
        Console.WriteLine("{0}", whiteReduce.Replace(t1, @"${firstWS}"));
        Console.WriteLine("\nNext example ---------");
        Console.WriteLine("{0}", t2);
        Console.WriteLine("{0}", whiteReduce.Replace(t2, @"${firstWS}"));
        Console.WriteLine();
    }

Lütfen ikinci örneğin tek tuttuğunu \n, kabul edilen cevabın satır sonunu boşlukla değiştireceğini unutmayın.

Beyaz boşluk karakterlerinin herhangi bir kombinasyonunu ilkiyle değiştirmeniz gerekirse , arka referansı \kdesenden kaldırmanız yeterlidir .

2 veya daha fazla beyaz alanı tek boşlukla değiştirmek için normal ifadeyi kullanmak da iyi bir çözümdür.

Normal ifade kalıbını " \ s + " olarak kullanıyoruz.

• \ s; boşluk, sekme, yeni satır, satır başı, form besleme veya dikey sekmeyle eşleşir.

• "+" bir veya daha fazla tekrarı belirtir.

Normal İfade Örneği

String blogName = "  Sourav .  Pal.   "

 String nameWithProperSpacing = blogName.replaceAll("\\s+", " ");   
System.out.println( nameWithProperSpacing );

Bunu yapmak için yerleşik bir yol yok. Bunu deneyebilirsiniz:

private static readonly char[] whitespace = new char[] { ' ', '\n', '\t', '\r', '\f', '\v' };
public static string Normalize(string source)
{
   return String.Join(" ", source.Split(whitespace, StringSplitOptions.RemoveEmptyEntries));
}

Bu, baştaki ve sondaki beyaz boşlukları kaldıracak ve herhangi bir dahili beyaz boşluğu tek bir boşluk karakterine daraltacaktır. Eğer gerçekten sadece boşlukları daraltmak istiyorsanız, düzenli ifade kullanan çözümler daha iyidir; aksi takdirde bu çözüm daha iyidir. ( Jon Skeet tarafından yapılan analize bakın .)