Comment remplacer plusieurs espaces par un seul espace en C #?
Comment puis-je remplacer plusieurs espaces dans une chaîne avec un seul espace en C #?
Exemple:
1 2 3 4 5
serait:
1 2 3 4 5
RegexOptions options = RegexOptions.None;
Regex regex = new Regex("[ ]{2,}", options);
tempo = regex.Replace(tempo, " ");
J'aime utiliser:
myString = Regex.Replace(myString, @"\s+", " ");
Puisqu'il capturera des espaces de tout type d'espaces (ex: onglets, nouvelles lignes, etc.) et les remplacera par un seul espace.
string xyz = "1 2 3 4 5";
xyz = string.Join( " ", xyz.Split( new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries ));
Je pense que la réponse de Matt est la meilleure, mais je ne pense pas que ce soit tout à fait juste. Si vous souhaitez remplacer les nouvelles lignes, vous devez utiliser:
myString = Regex.Replace(myString, @"\s+", " ", RegexOptions.Multiline);
Une autre approche qui utilise LINQ:
var list = str.Split(' ').Where(s => !string.IsNullOrWhiteSpace(s));
str = string.Join(" ", list);
C'est beaucoup plus simple que tout ça:
while(str.Contains(" ")) str = str.Replace(" ", " ");
La regex peut être assez lente même avec des tâches simples. Cela crée une méthode d'extension qui peut être utilisée à partir de toute variable 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();
}
}
Il serait utilisé comme tel:
string testValue = "This contains too much whitespace."
testValue = testValue.ReduceWhitespace();
// testValue = "This contains too much whitespace."
myString = Regex.Replace(myString, " {2,}", " ");
Pour ceux qui n'aiment pas Regex, voici une méthode qui utilise la 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();
}
Lors de mes tests, cette méthode était en moyenne 16 fois plus rapide avec un très grand ensemble de chaînes de taille petite à moyenne comparée à un regex statique compilé. Comparé à un Regex non compilé ou non statique, cela devrait être encore plus rapide.
Gardez à l'esprit que pas supprime les espaces de début ou de fin, mais seulement plusieurs occurrences de ce type.
Vous pouvez simplement le faire en une seule solution!
string s = "welcome to london";
s.Replace(" ", "()").Replace(")(", "").Replace("()", " ");
Vous pouvez choisir d'autres crochets (ou même d'autres caractères) si vous le souhaitez.
no Regex, no Linq ... supprime les espaces de début et de fin et réduit tous les segments d'espace multiples incorporés en un seul espace
string myString = " 0 1 2 3 4 5 ";
myString = string.Join(" ", myString.Split(new char[] { ' ' },
StringSplitOptions.RemoveEmptyEntries));
résultat: "0 1 2 3 4 5"
Il s'agit d'une version plus courte, qui ne devrait être utilisée que si vous ne le faites qu'une fois, car elle crée une nouvelle instance de la classe Regex à chaque appel.
temp = new Regex(" {2,}").Replace(temp, " ");
Si vous n'êtes pas trop familiarisé avec les expressions régulières, voici une courte explication:
Le {2,} permet au regex de rechercher le caractère le précédant et de rechercher des sous-chaînes entre 2 fois et des temps illimités.
La .Replace(temp, " ") remplace toutes les correspondances dans la chaîne temp par un espace.
Si vous souhaitez utiliser cela plusieurs fois, voici une meilleure option, car elle crée l'IL regex au moment de la compilation:
Regex singleSpacify = new Regex(" {2,}", RegexOptions.Compiled);
temp = singleSpacify.Replace(temp, " ");
Consolidant d'autres réponses, par Joel, et, espérons-le, s'améliorant légèrement au fur et à mesure:
Vous pouvez le faire avec Regex.Replace() :
string s = Regex.Replace (
" 1 2 4 5",
@"[ ]{2,}",
" "
);
Ou avec String.Split() :
static class StringExtensions
{
public static string Join(this IList<string> value, string separator)
{
return string.Join(separator, value.ToArray());
}
}
//...
string s = " 1 2 4 5".Split (
" ".ToCharArray(),
StringSplitOptions.RemoveEmptyEntries
).Join (" ");
Je viens d'écrire une nouvelle Join que j'aime bien, alors j'ai pensé répondre à nouveau avec:
public static string Join<T>(this IEnumerable<T> source, string separator)
{
return string.Join(separator, source.Select(e => e.ToString()).ToArray());
}
L'un des avantages de cette solution est que cela fonctionne avec des collections qui ne sont pas des chaînes, en appelant ToString () sur les éléments. L'utilisation est toujours la même:
//...
string s = " 1 2 4 5".Split (
" ".ToCharArray(),
StringSplitOptions.RemoveEmptyEntries
).Join (" ");
Je sais que c'est assez vieux, mais je l'ai vu en essayant de faire presque la même chose. Trouvé cette solution dans RegEx Buddy. Ce modèle remplacera tous les espaces doubles par des espaces simples et supprimera également les espaces de début et de fin.
pattern: (?m:^ +| +$|( ){2,})
replacement: $1
C'est un peu difficile à lire puisque nous avons affaire à des espaces vides, donc le voici à nouveau avec les "espaces" remplacés par un "_".
pattern: (?m:^_+|_+$|(_){2,}) <-- don't use this, just for illustration.
La construction "(? M:" active l'option "multi-lignes". J'aime généralement inclure toutes les options possibles dans le modèle lui-même afin qu'il soit plus autonome.
essayez cette méthode
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();
}
utilisez-le comme ceci:
string test = removeNestedWhitespaces("1 2 3 4 5".toCharArray());
Je peux supprimer les espaces avec ce
while Word.contains(" ") //double space
Word = Word.Replace(" "," "); //replace double space by single space.
Word = Word.trim(); //to remove single whitespces from start & end.
Beaucoup de réponses donnent le bon résultat, mais pour ceux qui recherchent les meilleures performances, j'ai amélioré la réponse de Nolanar (qui était la meilleure réponse en termes de performance) d'environ 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();
}
}
Vieille école:
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 " ) );
Utilisez le motif regex
[ ]+ #only space
var text = Regex.Replace(inputString, @"[ ]+", " ");
Sans utiliser d'expressions régulières:
while (myString.IndexOf(" ", StringComparison.CurrentCulture) != -1)
{
myString = myString.Replace(" ", " ");
}
OK pour une utilisation sur des chaînes courtes, mais se comporte mal sur de longues chaînes avec beaucoup d'espace.
Mélange de StringBuilder et Enumerable.Aggregate () as méthode d'extension pour les chaînes:
using System;
using System.Linq;
using System.Text;
public static class StringExtension
{
public static string StripSpaces(this string s)
{
return s.Aggregate(new StringBuilder(), (acc, c) =>
{
if (c != ' ' || acc.Length > 0 && acc[acc.Length-1] != ' ')
acc.Append(c);
return acc;
}).ToString();
}
public static void Main()
{
Console.WriteLine("\"" + StringExtension.StripSpaces("1 Hello World 2 ") + "\"");
}
}
Contribution:
"1 Hello World 2 "
Sortie:
"1 Hello World 2 "
// Mysample string
string str ="hi you are a demo";
//Split the words based on white sapce
var demo= str .Split(' ').Where(s => !string.IsNullOrWhiteSpace(s));
//Join the values back and add a single space in between
str = string.Join(" ", demo);
//output: string str ="hi you are a demo";