Come posso sostituire più spazi con un singolo spazio in C #?

Come posso sostituire più spazi in una stringa con un solo spazio in C #?

Esempio:

1 2 3 4 5 

sarebbe:

 1 2 3 4 5 

 RegexOptions options = RegexOptions.None; Regex regex = new Regex("[ ]{2,}", options); tempo = regex.Replace(tempo, " "); 

Mi piace usare:

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

Dal momento che catturerà esecuzioni di qualsiasi tipo di spazio bianco (es. Tabulazioni, newline, ecc.) E le sostituirà con un singolo spazio.

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

Penso che la risposta di Matt sia la migliore, ma non credo sia giusto. Se vuoi sostituire i newline, devi usare:

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

È molto più semplice di tutto ciò:

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

Un altro approccio che usa LINQ:

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

Regex può essere piuttosto lento anche con compiti semplici. Questo crea un metodo di estensione che può essere utilizzato da qualsiasi 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(); } } 

Sarebbe usato come tale:

 string testValue = "This contains too much whitespace." testValue = testValue.ReduceWhitespace(); // testValue = "This contains too much whitespace." 
 myString = Regex.Replace(myString, " {2,}", " "); 

Per coloro a cui non piace Regex , ecco un metodo che usa 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(); } 

Nei miei test, questo metodo era in media 16 volte più veloce con un insieme molto grande di stringhe di piccole e medie dimensioni, rispetto a un Regex compilato statico. Rispetto a un Regex non compilato o non statico, questo dovrebbe essere ancora più veloce.

Tieni presente che non rimuove spazi iniziali o finali, ma solo ricorrenze multiple.

Puoi semplicemente farlo in una soluzione di linea!

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

Puoi scegliere altre parentesi (o anche altri caratteri) se lo desideri.

Questa è una versione più breve, che dovrebbe essere utilizzata solo se si esegue questa operazione solo una volta, poiché crea una nuova istanza della class Regex ogni volta che viene chiamata.

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

Se non conosci troppo le espressioni regolari, ecco una breve spiegazione:

Il {2,} fa la ricerca regolare per il carattere che lo precede e trova sottostringhe tra 2 e un numero illimitato di volte.
Il .Replace(temp, " ") sostituisce tutte le corrispondenze nella stringa temporanea con uno spazio.

Se si desidera utilizzare questo più volte, ecco un’opzione migliore, poiché crea l’espressione regolare IL in fase di compilazione:

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

Consolanciando altre risposte, per Joel, e, auspicabilmente, migliorando leggermente mentre vado:

Puoi farlo con Regex.Replace() :

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

Oppure con String.Split() :

 static class StringExtensions { public static string Join(this IList value, string separator) { return string.Join(separator, value.ToArray()); } } //... string s = " 1 2 4 5".Split ( " ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries ).Join (" "); 

no Regex, no Linq … rimuove gli spazi iniziali e finali e riduce qualsiasi spazio multiplo incorporato in uno spazio

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

risultato: “0 1 2 3 4 5”

So che questo è piuttosto vecchio, ma ci siamo imbattuti in questo mentre cercavo di ottenere quasi la stessa cosa. Ho trovato questa soluzione in RegEx Buddy. Questo schema sostituirà tutti i doppi spazi con singoli spazi e tratterà anche gli spazi iniziali e finali.

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

È un po ‘difficile da leggere visto che abbiamo a che fare con lo spazio vuoto, quindi eccolo di nuovo con gli “spazi” sostituiti con un “_”.

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

Il costrutto "(? M:" abilita l'opzione "multi-line". In genere mi piace includere tutte le opzioni che posso all'interno del pattern stesso in modo che sia più autonomo.

Ho appena scritto un nuovo Join che mi piace, quindi ho pensato di rispondere nuovamente, con esso:

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

Una delle cose migliori di questo è che funziona con le raccolte che non sono stringhe, chiamando ToString () sugli elementi. L’utilizzo è sempre lo stesso:

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

Posso rimuovere gli spazi bianchi con questo

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

Molte risposte stanno fornendo la giusta uscita ma per coloro che cercano le migliori prestazioni, ho migliorato la risposta di Nolanar (che era la migliore risposta per le prestazioni) di circa il 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(); } } 

prova questo metodo

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

usalo in questo modo:

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

Vecchia scuola:

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

Senza usare le espressioni regolari:

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

OK da usare su stringhe corte, ma si comporta male su stringhe lunghe con molti spazi.

Usa il modello regex

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