c# - मैं सी#में एक ही स्थान के साथ एकाधिक रिक्त स्थान कैसे बदलूं?




regex string (14)

मैं स्ट्रिंग में एकाधिक रिक्त स्थान को सी # में केवल एक स्थान के साथ कैसे बदल सकता हूं?

उदाहरण:

1 2 3  4    5

होने वाला:

1 2 3 4 5

LINQ का उपयोग करने वाला एक और दृष्टिकोण:

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

आप इसे एक लाइन समाधान में कर सकते हैं!

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

यदि आप चाहें तो आप अन्य ब्रैकेट (या यहां तक ​​कि अन्य पात्र) भी चुन सकते हैं।


कई जवाब सही आउटपुट प्रदान कर रहे हैं लेकिन सर्वश्रेष्ठ प्रदर्शन की तलाश करने वालों के लिए, मैंने नोलनार के उत्तर में सुधार किया (जो प्रदर्शन के लिए सबसे अच्छा जवाब था) लगभग 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();
    }

}

कोई रेगेक्स नहीं, कोई लिंक नहीं ... अग्रणी और पिछली जगहों को हटा देता है साथ ही साथ किसी भी एम्बेडेड एकाधिक स्पेस सेगमेंट को एक स्थान पर कम करता है

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

परिणाम: "0 1 2 3 4 5"


नियमित अभिव्यक्तियों का उपयोग किए बिना:

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

छोटे तारों पर उपयोग करने के लिए ठीक है, लेकिन बहुत सारी जगहों के साथ लंबे तारों पर बुरी तरह से प्रदर्शन करेगा।


पुराना विद्यालय:

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

मुझे पता है कि यह बहुत पुराना है, लेकिन लगभग एक ही चीज़ को पूरा करने की कोशिश करते हुए इस पर दौड़ गया। RegEx Buddy में यह समाधान मिला। यह पैटर्न सभी रिक्त स्थानों के साथ सभी डबल रिक्त स्थान को प्रतिस्थापित करेगा और अग्रणी और पिछली जगहों को भी ट्रिम करेगा।

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

जब हम रिक्त स्थान से निपट रहे हैं, तो इसे पढ़ने में थोड़ा मुश्किल है, इसलिए यहां "रिक्त स्थान" को "_" से बदल दिया गया है।

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

"(? एम:" निर्माण "बहु-रेखा" विकल्प को सक्षम बनाता है। मैं आम तौर पर पैटर्न के भीतर जो भी विकल्प कर सकता हूं उसे शामिल करना चाहता हूं, इसलिए यह अधिक आत्मनिर्भर है।


मुझे लगता है कि मैट का जवाब सबसे अच्छा है, लेकिन मुझे विश्वास नहीं है कि यह काफी सही है। यदि आप न्यूलाइन को प्रतिस्थापित करना चाहते हैं, तो आपको इसका उपयोग करना होगा:

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

मैंने अभी एक नया लिखा है जो मुझे पसंद है, इसलिए मैंने सोचा कि मैं फिर से जवाब दूंगा:

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

इसके बारे में अच्छी चीजों में से एक यह है कि यह उन तत्वों के साथ काम करता है जो तत्वों पर ToString () को कॉल करके स्ट्रिंग नहीं हैं। उपयोग अभी भी वही है:

//...

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

यह एक छोटा संस्करण है, जिसका उपयोग केवल तभी किया जाना चाहिए जब आप केवल एक बार ऐसा कर रहे हों, क्योंकि यह हर बार Regex कक्षा का एक नया उदाहरण बनाता है।

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

यदि आप नियमित अभिव्यक्तियों से परिचित नहीं हैं, तो यहां एक संक्षिप्त विवरण दिया गया है:

{2,} इससे पहले के चरित्र के लिए रेगेक्स खोज बनाता है, और 2 और असीमित समय के बीच सबस्ट्रिंग पाता है।
.Replace(temp, " ") एक स्ट्रिंग temp में सभी मैचों को एक स्थान के साथ बदल देता है।

यदि आप इस कई बार उपयोग करना चाहते हैं, तो यहां एक बेहतर विकल्प है, क्योंकि यह संकलन समय पर रेगेक्स आईएल बनाता है:

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

रेगेक्स सरल कार्यों के साथ भी धीमा हो सकता है। यह एक विस्तार विधि बनाता है जिसका उपयोग किसी भी 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();
        }
    }

इसका उपयोग इस प्रकार किया जाएगा:

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

इस विधि को आजमाएं

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++;
    }
    return sb.ToString();
}

इस तरह इसका इस्तेमाल करें:

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

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

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







string