दिलचस्प पोस्ट
अपने IComparer का प्रयोग करें <T> Linq आदेश के साथ POST और GET के बीच अंतर क्या है? एक विशिष्ट शब्द का उपयोग करके और किसी अन्य एक्सेल शीट को चिपकाने में एक पंक्ति की प्रतिलिपि कैसे करें? मेमोरी लीक का निदान – # बाइट्स की स्वीकार्य स्मृति आकार समाप्त हो गया दूसरे पृष्ठ पर एक div की सामग्री लोड करें जावास्क्रिप्ट में दिनांक / समय कैसे घटाना है? पाप्लोट के साथ एक सर्कल का प्लॉट करें चर के साथ ब्रेस विस्तार? सी ++ संदर्भ से मुक्त या संदर्भ-संवेदनशील है? डिफ़ॉल्ट ऑब्जेक्ट.स्टोस्टिंग () क्यों हैशोड में शामिल है? PHP फ़ाइल कोड के कुछ भाग को दर्ज नहीं कर सकती आर में विखंडों में सदिश को विभाजित करें आप एक EC2 आवृत्ति में स्वैप कैसे जोड़ सकते हैं? फ्लेक्सबॉक्स के साथ नीचे एक तत्व को संरेखित करें आरपीसी फ्रेमवर्क और अपाचे थ्रिफ्ट क्या है?

स्ट्रिंग से सभी व्हाट्सपेस को निकालने का कुशल तरीका?

मैं एक आरईएसटी एपीआई कह रहा हूं और एक XML प्रतिक्रिया वापस प्राप्त कर रहा हूं। यह एक कार्यस्थान नामों की एक सूची देता है, और मैं एक त्वरित IsExistingWorkspace() विधि लिख रहा हूँ। चूंकि सभी वर्कस्पेस में कोई श्वेत स्थान नहीं है, इसलिए मैं यह पता लगाने का सबसे आसान तरीका मान रहा हूं कि सूची में कोई विशेष कार्यस्थान है, सभी सफेद स्थान (न्यूलाइन सहित) को हटाने और ऐसा करने से (XML वेब से प्राप्त स्ट्रिंग है निवेदन):

 XML.Contains("<name>" + workspaceName + "</name>"); 

मुझे पता है कि यह केस-संवेदी है, और मैं इस पर भरोसा कर रहा हूं। मुझे स्ट्रिंग में सभी श्वेतस्थान को कुशलतापूर्वक निकालने का एक तरीका चाहिए। मुझे पता है कि RegEx और LINQ ऐसा कर सकते हैं, लेकिन मैं अन्य विचारों के लिए खुला हूँ मैं ज्यादातर गति के बारे में बस चिंतित हूँ

वेब के समाधान से एकत्रित समाधान "स्ट्रिंग से सभी व्हाट्सपेस को निकालने का कुशल तरीका?"

यह सबसे तेज़ तरीका है जिसे मैं जानता हूं, भले ही आपने कहा था कि आप नियमित अभिव्यक्ति का उपयोग नहीं करना चाहते थे:

 Regex.Replace(XML, @"\s+", "") 

मेरे पास एक वैकल्पिक तरीका है regexp के बिना, और यह बहुत अच्छा प्रदर्शन करने लगता है। यह ब्रेंडन मोरेत्ज़ के जवाब पर एक निरंतरता है:

  public static string RemoveWhitespace(this string input) { return new string(input.ToCharArray() .Where(c => !Char.IsWhiteSpace(c)) .ToArray()); } 

मैंने इसे एक साधारण इकाई परीक्षण में परीक्षण किया:

 [Test] [TestCase("123 123 1adc \n 222", "1231231adc222")] public void RemoveWhiteSpace1(string input, string expected) { string s = null; for (int i = 0; i < 1000000; i++) { s = input.RemoveWhitespace(); } Assert.AreEqual(expected, s); } [Test] [TestCase("123 123 1adc \n 222", "1231231adc222")] public void RemoveWhiteSpace2(string input, string expected) { string s = null; for (int i = 0; i < 1000000; i++) { s = Regex.Replace(input, @"\s+", ""); } Assert.AreEqual(expected, s); } 

1,000,000 प्रयासों के लिए पहला विकल्प (बिना रेगेक्सपी) कम से कम एक सेकंड (मेरी मशीन पर 700 एमएस) चलता है, और दूसरा 3.5 सेकंड लेता है।

सी # में स्ट्रिंग की प्रतिस्थापन विधि को आज़माएं

 XML.Replace(" ", string.Empty); 

मेरा समाधान स्प्लिट का उपयोग करना है और इसमें शामिल होना और यह आश्चर्यजनक रूप से तेजी से है, वास्तव में शीर्ष उत्तरों का सबसे तेज़ी यहाँ है।

 str = string.Join("", str.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries)); 

व्हाइटस्पेस इंक नई लाइनों और टैब के साथ सरल स्ट्रिंग पर 10,000 पाश के लिए समय

  • विभाजन / जुड़ें = 60 मिलीसेकंड्स
  • linq chararray = 94 मिलीसेकंड्स
  • regex = 437 मिलीसेकंड्स

इसे अर्थ देने के लिए विधि में इसे लपेटकर इसे बेहतर बनाएं, और इसे एक एक्सटेंशन विधि बनाते समय हम उस पर हैं …

 public static string RemoveWhitespace(this string str) { return string.Join("", str.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries)); } 

बस एक विकल्प है क्योंकि यह बहुत अच्छा लग रहा है 🙂 – नोट: हेनक्स का जवाब इनमें से सबसे तेज है।

 input.ToCharArray() .Where(c => !Char.IsWhiteSpace(c)) .Select(c => c.ToString()) .Aggregate((a, b) => a + b); 

"This is a simple Test" पर 1,000,000 छोरों का परीक्षण करना

यह विधि = 1.74 सेकंड
रेगेक्स = 2.58 सेकंड
new String (हेनक्स) = 0.82

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

लंबी इनपुट स्ट्रिंग परिणाम:

  1. इनप्लेसचरअरे: 2021 एमएस ( सनसेटक्वेस्ट का जवाब ) – ( मूल स्रोत )
  2. स्ट्रिंग रीडर: 6082 एमएस
  3. मूल वर्णों का उपयोग कर LINQ। वेबस्पेस: 7357 एमएस
  4. LINQ: 7746 एमएस ( हेन्क का जवाब )
  5. ForLoop: 32320 एमएस
  6. रेगेक्स कॉम्पैप्टेड: 37157 एमएस
  7. रेगेक्स: 42 9 40 एमएस

लघु इनपुट स्ट्रिंग परिणाम:

  1. इनप्लेसचरअरे: 108 एमएस ( सनसेटक्वेस्ट का जवाब ) – ( मूल स्रोत )
  2. स्ट्रिंग रीडर: 327 एमएस
  3. ForLoop: 343 एमएस
  4. मूल वर्णों का उपयोग कर LINQ। वेबस्पेस: 624 एमएस
  5. LINQ: 645 एमएमएस (हैन्क का जवाब )
  6. Regexcompiled: 1671 एमएस
  7. रेगेक्स: 25 99 एमएस

कोड :

 public class RemoveWhitespace { public static string RemoveStringReader(string input) { var s = new StringBuilder(input.Length); // (input.Length); using (var reader = new StringReader(input)) { int i = 0; char c; for (; i < input.Length; i++) { c = (char)reader.Read(); if (!char.IsWhiteSpace(c)) { s.Append(c); } } } return s.ToString(); } public static string RemoveLinqNativeCharIsWhitespace(string input) { return new string(input.ToCharArray() .Where(c => !char.IsWhiteSpace(c)) .ToArray()); } public static string RemoveLinq(string input) { return new string(input.ToCharArray() .Where(c => !Char.IsWhiteSpace(c)) .ToArray()); } public static string RemoveRegex(string input) { return Regex.Replace(input, @"\s+", ""); } private static Regex compiled = new Regex(@"\s+", RegexOptions.Compiled); public static string RemoveRegexCompiled(string input) { return compiled.Replace(input, ""); } public static string RemoveForLoop(string input) { for (int i = input.Length - 1; i >= 0; i--) { if (char.IsWhiteSpace(input[i])) { input = input.Remove(i, 1); } } return input; } public static string RemoveInPlaceCharArray(string input) { var len = input.Length; var src = input.ToCharArray(); int dstIdx = 0; for (int i = 0; i < len; i++) { var ch = src[i]; switch (ch) { case '\u0020': case '\u00A0': case '\u1680': case '\u2000': case '\u2001': case '\u2002': case '\u2003': case '\u2004': case '\u2005': case '\u2006': case '\u2007': case '\u2008': case '\u2009': case '\u200A': case '\u202F': case '\u205F': case '\u3000': case '\u2028': case '\u2029': case '\u0009': case '\u000A': case '\u000B': case '\u000C': case '\u000D': case '\u0085': continue; default: src[dstIdx++] = ch; break; } } return new string(src, 0, dstIdx); } } 

टेस्ट :

 [TestFixture] public class Test { // Short input //private const string input = "123 123 \t 1adc \n 222"; //private const string expected = "1231231adc222"; // Long input private const string input = "123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222"; private const string expected = "1231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc222"; private const int iterations = 1000000; [Test] public void RemoveInPlaceCharArray() { string s = null; var stopwatch = Stopwatch.StartNew(); for (int i = 0; i < iterations; i++) { s = RemoveWhitespace.RemoveInPlaceCharArray(input); } stopwatch.Stop(); Console.WriteLine("InPlaceCharArray: " + stopwatch.ElapsedMilliseconds + " ms"); Assert.AreEqual(expected, s); } [Test] public void RemoveStringReader() { string s = null; var stopwatch = Stopwatch.StartNew(); for (int i = 0; i < iterations; i++) { s = RemoveWhitespace.RemoveStringReader(input); } stopwatch.Stop(); Console.WriteLine("String reader: " + stopwatch.ElapsedMilliseconds + " ms"); Assert.AreEqual(expected, s); } [Test] public void RemoveLinqNativeCharIsWhitespace() { string s = null; var stopwatch = Stopwatch.StartNew(); for (int i = 0; i < iterations; i++) { s = RemoveWhitespace.RemoveLinqNativeCharIsWhitespace(input); } stopwatch.Stop(); Console.WriteLine("LINQ using native char.IsWhitespace: " + stopwatch.ElapsedMilliseconds + " ms"); Assert.AreEqual(expected, s); } [Test] public void RemoveLinq() { string s = null; var stopwatch = Stopwatch.StartNew(); for (int i = 0; i < iterations; i++) { s = RemoveWhitespace.RemoveLinq(input); } stopwatch.Stop(); Console.WriteLine("LINQ: " + stopwatch.ElapsedMilliseconds + " ms"); Assert.AreEqual(expected, s); } [Test] public void RemoveRegex() { string s = null; var stopwatch = Stopwatch.StartNew(); for (int i = 0; i < iterations; i++) { s = RemoveWhitespace.RemoveRegex(input); } stopwatch.Stop(); Console.WriteLine("Regex: " + stopwatch.ElapsedMilliseconds + " ms"); Assert.AreEqual(expected, s); } [Test] public void RemoveRegexCompiled() { string s = null; var stopwatch = Stopwatch.StartNew(); for (int i = 0; i < iterations; i++) { s = RemoveWhitespace.RemoveRegexCompiled(input); } stopwatch.Stop(); Console.WriteLine("RegexCompiled: " + stopwatch.ElapsedMilliseconds + " ms"); Assert.AreEqual(expected, s); } [Test] public void RemoveForLoop() { string s = null; var stopwatch = Stopwatch.StartNew(); for (int i = 0; i < iterations; i++) { s = RemoveWhitespace.RemoveForLoop(input); } stopwatch.Stop(); Console.WriteLine("ForLoop: " + stopwatch.ElapsedMilliseconds + " ms"); Assert.AreEqual(expected, s); } } 

यदि आपको शानदार प्रदर्शन की आवश्यकता है, तो आपको इस मामले में LINQ और नियमित अभिव्यक्ति से बचना चाहिए। मैंने कुछ प्रदर्शन बेंचमार्किंग किया था, और ऐसा लगता है कि यदि आप स्ट्रिंग की शुरुआत और अंत से सफेद स्थान पट्टी करना चाहते हैं, तो string.Rim () आपका अंतिम कार्य है

यदि आपको स्ट्रिंग से सभी सफेद रिक्त स्थान पट्टी करने की आवश्यकता है, तो निम्न विधि उन सभी पर सबसे तेज़ी से काम करती है जिन्हें यहां पोस्ट किया गया है:

  public static string RemoveWhitespace(this string input) { int j = 0, inputlen = input.Length; char[] newarr = new char[inputlen]; for (int i = 0; i < inputlen; ++i) { char tmp = input[i]; if (!char.IsWhiteSpace(tmp)) { newarr[j] = tmp; ++j; } } return new String(newarr, 0, j); } 

मुझे फिलिप मचाडो द्वारा CodeProject ( रिचर्ड रॉबर्टसन द्वारा सहायता के साथ) पर इस पर एक अच्छा लिखना मिला।

उसने दस विभिन्न तरीकों का परीक्षण किया यह एक सबसे तेज़ असुरक्षित संस्करण है …

 public static unsafe string TrimAllWithStringInplace(string str) { fixed (char* pfixed = str) { char* dst = pfixed; for (char* p = pfixed; *p != 0; p++) switch (*p) { case '\u0020': case '\u00A0': case '\u1680': case '\u2000': case '\u2001': case '\u2002': case '\u2003': case '\u2004': case '\u2005': case '\u2006': case '\u2007': case '\u2008': case '\u2009': case '\u200A': case '\u202F': case '\u205F': case '\u3000': case '\u2028': case '\u2029': case '\u0009': case '\u000A': case '\u000B': case '\u000C': case '\u000D': case '\u0085': continue; default: *dst++ = *p; break; } return new string(pfixed, 0, (int)(dst - pfixed)); } 

और सबसे तेज़ सुरक्षित संस्करण …

 public static string TrimAllWithInplaceCharArray(string str) { var len = str.Length; var src = str.ToCharArray(); int dstIdx = 0; for (int i = 0; i < len; i++) { var ch = src[i]; switch (ch) { case '\u0020': case '\u00A0': case '\u1680': case '\u2000': case '\u2001': case '\u2002': case '\u2003': case '\u2004': case '\u2005': case '\u2006': case '\u2007': case '\u2008': case '\u2009': case '\u200A': case '\u202F': case '\u205F': case '\u3000': case '\u2028': case '\u2029': case '\u0009': case '\u000A': case '\u000B': case '\u000C': case '\u000D': case '\u0085': continue; default: src[dstIdx++] = ch; break; } } return new string(src, 0, dstIdx); } 

Stian Standahl द्वारा स्टैक ओवरफ्लो पर कुछ अच्छे स्वतंत्र मानक भी दिखाए गए हैं जो यह भी दिखाते हैं कि फेलिप का कार्य अगले सबसे तेज़ समारोह की तुलना में लगभग 300% अधिक तेज़ है।

रेगेक्स ओवरकिल है; बस स्ट्रिंग पर विस्तार का उपयोग करें (धन्यवाद हेन्क) यह तुच्छ है और ढांचे का हिस्सा होना चाहिए था। किसी भी तरह, यहां मेरा कार्यान्वयन है:

 public static partial class Extension { public static string RemoveWhiteSpace(this string self) { return new string(self.Where(c => !Char.IsWhiteSpace(c)).ToArray()); } } 

यहां रेगएक्स समाधान का एक सरल रेखीय विकल्प है मुझे यकीन नहीं है कि कौन सा तेज है; आपको इसे बेंचमार्क करना होगा

 static string RemoveWhitespace(string input) { StringBuilder output = new StringBuilder(input.Length); for (int index = 0; index < input.Length; index++) { if (!Char.IsWhiteSpace(input, index)) { output.Append(input[index]); } } return output.ToString(); } 

मैं मानता हूं कि आपकी XML प्रतिक्रिया इस तरह दिखती है:

 var xml = @"<names> <name> foo </name> <name> bar </name> </names>"; 

XML प्रसंस्करण का सबसे अच्छा तरीका है एक XML पार्सर का उपयोग करना, जैसे कि LINQ से XML :

 var doc = XDocument.Parse(xml); var containsFoo = doc.Root .Elements("name") .Any(e => ((string)e).Trim() == "foo"); 

मुझे रिक्त स्थान के साथ एक स्ट्रिंग में सफेद स्थान को बदलने की जरूरत है, लेकिन रिक्त स्थान डुप्लिकेट नहीं है जैसे, मुझे निम्नलिखित की तरह कुछ बदलने की जरूरत है:

 "abc\r\nd\t\t\te" 

सेवा मेरे

 "abcde" 

मैंने निम्नलिखित विधि का इस्तेमाल किया

 private static string RemoveWhiteSpace(string value) { if (value == null) { return null; } var sb = new StringBuilder(); var lastCharWs = false; foreach (var c in value) { if (char.IsWhiteSpace(c)) { if (lastCharWs) { continue; } sb.Append(' '); lastCharWs = true; } else { sb.Append(c); lastCharWs = false; } } return sb.ToString(); } 

मैंने सच होने के लिए अलग-अलग परिणाम पाये हैं मैं सभी जगहों को एक स्थान से बदलने की कोशिश कर रहा हूं और regex बहुत धीमा था

 return( Regex::Replace( text, L"\s+", L" " ) ); 

मेरे लिए सबसे बेहतर काम किसने किया (सी ++ सीएलआई में):

 String^ ReduceWhitespace( String^ text ) { String^ newText; bool inWhitespace = false; Int32 posStart = 0; Int32 pos = 0; for( pos = 0; pos < text->Length; ++pos ) { wchar_t cc = text[pos]; if( Char::IsWhiteSpace( cc ) ) { if( !inWhitespace ) { if( pos > posStart ) newText += text->Substring( posStart, pos - posStart ); inWhitespace = true; newText += L' '; } posStart = pos + 1; } else { if( inWhitespace ) { inWhitespace = false; posStart = pos; } } } if( pos > posStart ) newText += text->Substring( posStart, pos - posStart ); return( newText ); } 

मैंने प्रत्येक चरित्र को अलग से बदलकर पहली बार ऊपर की कोशिश की, लेकिन गैर-अंतरिक्ष वर्गों के लिए सबस्ट्रिंग करने पर स्विच करना पड़ा। 1,200,000 वर्ण स्ट्रिंग के लिए आवेदन करते समय:

  • उपरोक्त दिनचर्या इसे 25 सेकंड में किया जाता है
  • उपरोक्त नियमित + 95 सेकंड में अलग-अलग वर्ण प्रतिस्थापन
  • 15 मिनट के बाद रगेक्स को निरस्त कर दिया गया

यहां एक और संस्करण भी है:

 public static string RemoveAllWhitespace(string aString) { return String.Join(String.Empty, aString.Where(aChar => aChar !Char.IsWhiteSpace(aChar))); } 

अधिकांश अन्य समाधानों के साथ, मैंने संपूर्ण बेंचमार्क परीक्षण नहीं किए हैं, लेकिन यह मेरे उद्देश्यों के लिए पर्याप्त रूप से काम करता है

हम प्रयोग कर सकते हैं:

  public static string RemoveWhitespace(this string input) { if (input == null) return null; return new string(input.ToCharArray() .Where(c => !Char.IsWhiteSpace(c)) .ToArray()); } 

मान लें कि हमारे पास यह स्ट्रिंग है: string MyString = " test test test" आप अपनी स्ट्रिंग को एक स्थान सीमांकक के साथ विभाजित कर सकते हैं: MyString.Split(' ') यह खाली स्ट्रिंग और अन्य चार्टर के सरणी का परिणाम है इस स्थिति में यह इस सरणी को उत्पन्न करता है: { "", "test", "test", "", "", "", "test" } । फिर string.concat विधि का उपयोग करके आप सभी स्ट्रिंग को सरणी में "testtesttest" जो परिणाम "testtesttest"

 string MyString = " test test test"; MyString = string.Concat(MyString.Split(' ')); 

हम System.Linq का उपयोग कर सकते हैं और हम इसे एक पंक्ति में कर सकते हैं:

 string text = "My text with white spaces..."; text = new string(text.ToList().Where(c => c != ' ').ToArray()); 
 String s = Console.ReadLine(); s = s.Replace(" ", String.Empty); String[] arr = s.Split(' '); foreach(char num in s) { Console.WriteLine(num); } 

कोड का यह ब्लॉक स्ट्रिंग से सभी रिक्त स्थान निकाल देता है।