¿Cuál es la manera más rápida para reemplazar más espacios en blanco a un espacio en blanco?

por ejemplo,

de

foo      bar 

a

foo bar

25 Comentarios

  1. 49

    La manera más rápida? Iterar a través de la cadena y crear una segunda copia en un StringBuilder carácter por carácter, sólo copiar un espacio para cada grupo de espacios.

    Más fácil para el tipo de Replace variantes creará un cubo de carga de cadenas adicionales (o perder el tiempo de la construcción de la regex DFA).

    Editar con los resultados de la comparación:

    Utilizando http://ideone.com/NV6EzU, con n=50 (tuvo que reducir en ideone porque tomó tanto tiempo que había que matar el proceso), me sale:

    Regex: 7771ms.

    Stringbuilder: 894ms.

    Que es, de hecho, como se esperaba, Regex es terriblemente ineficiente para algo tan simple.

    • Un Compiled regex va a ejecutar tan rápido como cualquier cosa que usted puede escribir
    • otro de barrido generalización desmentido!
    • Tienes razón, nunca me hubiera dado cuenta de que.
    • Compilación de Expresión sólo tiene sentido si está procesando un montón de cadenas en un lote.
    • Su enlace, (ideone.com/h6pw3) está muerto.
    • Que es lo que sucede a 3 años (casi 4) entradas antiguas, enlaces a veces dejan de funcionar. Usted sólo tendrá que tomar mi palabra para ella.
    • Podría entonces tal vez agregar el código que se utiliza directamente a tu respuesta? Gracias de antemano!
    • Blindy, voy a upvote si usted puede agregar el código fuente desde el enlace que ahora está roto. Los enlaces están mal en StackOverflow. Siempre es mejor publicar el código fuente.
    • Usted no necesita la fuente, he descrito el algoritmo en suficiente detalle. El programa conectado es sólo para la comparación de velocidad.
    • ¿Qué acerca de string resultString = string.Join(" ", sourceString.Split(' ').Where(s => s != ""));?
    • Split también es ridículamente lento, usted está poniendo presión sobre el montón de ninguna razón por la asignación de la matriz.
    • He reinstalado el enlace de web.archive.org 😉

  2. 41

    Puede utilizar una expresión regular:

    static readonly Regex trimmer = new Regex(@"\s\s+");
    
    s = trimmer.Replace(s, " ");

    Para mayor rendimiento, pasar RegexOptions.Compiled.

    • Véase también este ejemplo
    • Pero este código elimina todas retorno charactars
    • Reemplazar \s con un espacio: new Regex(@" +") (dos caracteres de espacio)
    • Gracias funciona muy bien
    • Es curioso que este es el aceptado la respuesta dada a su reclamación inicial sobre el rendimiento.
    • Gracias @SLaks

  3. 24

    Un poco tarde, pero he hecho un poco de benchmarking para obtener la forma más rápida para eliminar el exceso de espacios en blanco. Si hay más respuestas, me gustaría agregar.

    Resultados:

    1. NormalizeWhiteSpaceForLoop: 156 ms (por Mí De mi respuesta en la eliminación de todos los espacios en blanco)
    2. NormalizeWhiteSpace: 267 ms (por Alex K.)
    3. RegexCompiled: 1950 ms (por SLaks)
    4. Regex: 2261 ms (por SLaks)

    Código:

    public class RemoveExtraWhitespaces
    {
    public static string WithRegex(string text)
    {
    return Regex.Replace(text, @"\s+", " ");
    }
    public static string WithRegexCompiled(Regex compiledRegex, string text)
    {
    return compiledRegex.Replace(text, " ");
    }
    public static string NormalizeWhiteSpace(string input)
    {
    if (string.IsNullOrEmpty(input))
    return string.Empty;
    int current = 0;
    char[] output = new char[input.Length];
    bool skipped = false;
    foreach (char c in input.ToCharArray())
    {
    if (char.IsWhiteSpace(c))
    {
    if (!skipped)
    {
    if (current > 0)
    output[current++] = ' ';
    skipped = true;
    }
    }
    else
    {
    skipped = false;
    output[current++] = c;
    }
    }
    return new string(output, 0, current);
    }
    public static string NormalizeWhiteSpaceForLoop(string input)
    {
    int len = input.Length,
    index = 0,
    i = 0;
    var src = input.ToCharArray();
    bool skip = false;
    char ch;
    for (; i < len; i++)
    {
    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':
    if (skip) continue;
    src[index++] = ch;
    skip = true;
    continue;
    default:
    skip = false;
    src[index++] = ch;
    continue;
    }
    }
    return new string(src, 0, index);
    }
    }

    Pruebas:

    [TestFixture]
    public class RemoveExtraWhitespacesTest
    {
    private const string _text = "foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo foo                  bar                  foobar                     moo ";
    private const string _expected = "foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo foo bar foobar moo ";
    private const int _iterations = 10000;
    [Test]
    public void Regex()
    {
    var result = TimeAction("Regex", () => RemoveExtraWhitespaces.WithRegex(_text));
    Assert.AreEqual(_expected, result);
    }
    [Test]
    public void RegexCompiled()
    {
    var compiledRegex = new Regex(@"\s+", RegexOptions.Compiled);
    var result = TimeAction("RegexCompiled", () => RemoveExtraWhitespaces.WithRegexCompiled(compiledRegex, _text));
    Assert.AreEqual(_expected, result);
    }
    [Test]
    public void NormalizeWhiteSpace()
    {
    var result = TimeAction("NormalizeWhiteSpace", () => RemoveExtraWhitespaces.NormalizeWhiteSpace(_text));
    Assert.AreEqual(_expected, result);
    }
    [Test]
    public void NormalizeWhiteSpaceForLoop()
    {
    var result = TimeAction("NormalizeWhiteSpaceForLoop", () => RemoveExtraWhitespaces.NormalizeWhiteSpaceForLoop(_text));
    Assert.AreEqual(_expected, result);
    }
    public string TimeAction(string name, Func<string> func)
    {
    var timer = Stopwatch.StartNew();
    string result = string.Empty; ;
    for (int i = 0; i < _iterations; i++)
    {
    result = func();
    }
    timer.Stop();
    Console.WriteLine(string.Format("{0}: {1} ms", name, timer.ElapsedMilliseconds));
    return result;
    }
    }
  4. 12

    Yo uso siguientes métodos: se manejan todos los espacios en blanco caracteres no sólo de los espacios, de guarnición de líder y trailing de espacios en blanco, eliminar el exceso de de espacios en blanco, y todos los espacios en blanco son sustituye al espacio char (así tendrá espacio uniforme separador). Y estos métodos son rápido.

    public static String CompactWhitespaces( String s )
    {
    StringBuilder sb = new StringBuilder( s );
    CompactWhitespaces( sb );
    return sb.ToString();
    }
    public static void CompactWhitespaces( StringBuilder sb )
    {
    if( sb.Length == 0 )
    return;
    //set [start] to first not-whitespace char or to sb.Length
    int start = 0;
    while( start < sb.Length )
    {
    if( Char.IsWhiteSpace( sb[ start ] ) )
    start++;
    else 
    break;
    }
    //if [sb] has only whitespaces, then return empty string
    if( start == sb.Length )
    {
    sb.Length = 0;
    return;
    }
    //set [end] to last not-whitespace char
    int end = sb.Length - 1;
    while( end >= 0 )
    {
    if( Char.IsWhiteSpace( sb[ end ] ) )
    end--;
    else 
    break;
    }
    //compact string
    int dest = 0;
    bool previousIsWhitespace = false;
    for( int i = start; i <= end; i++ )
    {
    if( Char.IsWhiteSpace( sb[ i ] ) )
    {
    if( !previousIsWhitespace )
    {
    previousIsWhitespace = true;
    sb[ dest ] = ' ';
    dest++;
    }
    }
    else
    {
    previousIsWhitespace = false;
    sb[ dest ] = sb[ i ];
    dest++;
    }
    }
    sb.Length = dest;
    }
    • Vale la pena destacar que un solo salto de línea, '\n', será reemplazado con un espacio, ' '.
  5. 8
    string q = " Hello     how are   you           doing?";
    string a = String.Join(" ", q.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries));
  6. 7
    string text = "foo       bar";
    text = Regex.Replace(text, @"\s+", " ");
    //text = "foo bar"

    Esta solución funciona con los espacios, tabulaciones y de salto de línea. Si desea que sólo los espacios, reemplazar ‘\s’ con ‘ ‘.

    • No re-analizar el regex cada vez.
  7. 7

    Yo necesitaba uno de estos para las grandes cadenas y vino para arriba con la siguiente rutina.

    Cualquier espacio en blanco consecutivos (incluyendo tabulaciones, saltos de línea) se reemplaza con lo que está en normalizeTo.
    Avance y retroceso de espacio en blanco se retira.

    Es alrededor de 8 veces más rápido que un RegEx con mi 5k->5 mil char cadenas.

    internal static string NormalizeWhiteSpace(string input, char normalizeTo = ' ')
    {
    if (string.IsNullOrEmpty(input))
    return string.Empty;
    int current = 0;
    char[] output = new char[input.Length];
    bool skipped = false;
    foreach (char c in input.ToCharArray())
    {
    if (char.IsWhiteSpace(c))
    {
    if (!skipped)
    {
    if (current > 0)
    output[current++] = normalizeTo;
    skipped = true;
    }
    }
    else
    {
    skipped = false;
    output[current++] = c;
    }
    }
    return new string(output, 0, skipped ? current - 1 : current);
    }
    • Esta solución lanza una excepción si el input = «» (espacio), en la línea de retorno. He cambiado a algo como esto, ahora funciona bien.
  8. 6
    string yourWord = "beep boop    baap beep   boop    baap             beep";
    yourWord = yourWord .Replace("  ", " |").Replace("| ", "").Replace("|", "");
    • Siempre y cuando usted no tiene un «|» en yourWord.
  9. 5

    He intentado usar StringBuilder para:

    1. quitar un espacio en blanco adicional subcadenas
    2. aceptar los caracteres de un bucle por la cadena original, como Blindy sugiere

    Aquí está el mejor equilibrio de rendimiento & legibilidad he encontrado (el uso de 100.000 iteración de temporización se ejecuta). A veces esto de las pruebas más rápido que un menos legible versión, en más de un 5% más lento. En mi pequeña cadena de prueba, regex toma 4.24 x tanto tiempo.

    public static string RemoveExtraWhitespace(string str)
    {
    var sb = new StringBuilder();
    var prevIsWhitespace = false;
    foreach (var ch in str)
    {
    var isWhitespace = char.IsWhiteSpace(ch);
    if (prevIsWhitespace && isWhitespace)
    {
    continue;
    }
    sb.Append(ch);
    prevIsWhitespace = isWhitespace;
    }
    return sb.ToString();
    }
    • Para el mejor uso de la memoria, usted puede dar StringBuilder capacidad inicial.
  10. 3

    No es rápido, pero si la simplicidad ayuda, esto funciona:

    while (text.Contains("  ")) text=text.Replace("  ", " ");
  11. 2

    intente esto:

    System.Text.RegularExpressions.Regex.Replace(input, @"\s+", " ");
    • No re-analizar el regex cada vez.
  12. 2

    Un par de requisitos no son claros en esta cuestión que merece una reflexión.

    1. ¿Quieres un único principio o al final de carácter de espacio en blanco?
    2. Cuando reemplace todo el espacio en blanco con un solo personaje, ¿quieres que el carácter para ser coherente? (es decir, muchas de estas soluciones, habría que reemplazar \t\t \t y » con ‘ ‘.

    Esta es una forma muy eficiente de la versión que reemplaza todo el espacio en blanco con un solo espacio y elimina cualquier iniciales y finales de espacio en blanco antes del bucle for.

      public static string WhiteSpaceToSingleSpaces(string input)
    {
    if (input.Length < 2) 
    return input;
    StringBuilder sb = new StringBuilder();
    input = input.Trim();
    char lastChar = input[0];
    bool lastCharWhiteSpace = false;
    for (int i = 1; i < input.Length; i++)
    {
    bool whiteSpace = char.IsWhiteSpace(input[i]);
    //Skip duplicate whitespace characters
    if (whiteSpace && lastCharWhiteSpace)
    continue;
    //Replace all whitespace with a single space.
    if (whiteSpace)
    sb.Append(' ');
    else
    sb.Append(input[i]);
    //Keep track of the last character's whitespace status
    lastCharWhiteSpace = whiteSpace;
    }
    return sb.ToString();
    }
  13. 2

    Este fragmento de código de buenas obras. No he medir el rendimiento.

    string text = "   hello    -  world,  here   we go  !!!    a  bc    ";
    string.Join(" ", text.Split().Where(x => x != ""));
    //Output
    //"hello - world, here we go !!! a bc"
  14. 1

    usted podría utilizar indexOf a primera agarrar donde el espacio en blanco de secuencias de inicio, a continuación, utilice método de reemplazo para cambiar el espacio en blanco para «». A partir de allí, se puede utilizar el índice que agarró y lugar de un carácter de espacio en blanco en ese lugar.

    • Esto implicará un montón de desperdicio de String instancias.
    • Cierto, no estoy familiarizado con las formas rápidas por desgracia.
    • Regex o StringBuilder
    • Buscando en los que ahora, este debe ser útil para el programa que estoy escribiendo actualmente.
  15. 1

    Que esto es divertido, pero en mi PC el siguiente método es tan rápido como Sergey Povalyaev del StringBulder enfoque – (~282ms de 1000 repeticiones, 10k src cadenas). No estoy seguro sobre el uso de memoria, aunque.

    string RemoveExtraWhiteSpace(string src, char[] wsChars){
    return string.Join(" ",src.Split(wsChars, StringSplitOptions.RemoveEmptyEntries));
    }

    Obviamente, funciona bien con cualquier carac – no sólo de los espacios.

    Aunque esto no es lo que el OP pidió – pero si lo que realmente necesita es reemplazar específico de caracteres consecutivos en una cadena con sólo una instancia puede utilizar esta relativamente eficiente método:

        string RemoveDuplicateChars(string src, char[] dupes){  
    var sd = (char[])dupes.Clone();  
    Array.Sort(sd);
    var res = new StringBuilder(src.Length);
    for(int i = 0; i<src.Length; i++){
    if( i==0 || src[i]!=src[i-1] || Array.BinarySearch(sd,src[i])<0){
    res.Append(src[i]); 
    }
    }
    return res.ToString();
    }
    • Esto no funcionará correctamente, por ejemplo: RemoveDuplicateChars(«aa–sdf una», new char[] { ‘a’ }) devolverá: «–sdf «, mientras que debería devolver «un–sdf una».
    • Bueno, la RemoveDuplicateChars no era el mejor nombre para este método, pero si nos fijamos en el OP pregunta se puede ver que el objetivo era sustituir en la cadena de origen a cualquier número de lo que puede ser considerado como un carácter de espacio en blanco con un solo espacio. así que mi comentario re «cualquier chars» significa que. Voy a editar mi respuesta para hacerla más evidente.
  16. 1
    public string GetCorrectString(string IncorrectString)
    {
    string[] strarray = IncorrectString.Split(' ');
    var sb = new StringBuilder();
    foreach (var str in strarray)
    {
    if (str != string.Empty)
    {
    sb.Append(str).Append(' ');
    }
    }
    return sb.ToString().Trim();
    }
  17. 1

    Acabo de batida esto, no lo he probado todavía, aunque. Pero yo sentí que este era elegante, y evita regex:

        ///<summary>
    ///Removes extra white space.
    ///</summary>
    ///<param name="s">
    ///The string
    ///</param>
    ///<returns>
    ///The string, with only single white-space groupings. 
    ///</returns>
    public static string RemoveExtraWhiteSpace(this string s)
    {
    if (s.Length == 0)
    {
    return string.Empty;
    }
    var stringBuilder = new StringBuilder();
    var whiteSpaceCount = 0;
    foreach (var character in s)
    {
    if (char.IsWhiteSpace(character))
    {
    whiteSpaceCount++;
    }
    else
    {
    whiteSpaceCount = 0;
    }
    if (whiteSpaceCount > 1)
    {
    continue;
    }
    stringBuilder.Append(character);
    }
    return stringBuilder.ToString();
    }
  18. 1

    Que me estoy perdiendo algo aquí? Se me ocurrió esto:

    //Input: "HELLO     BEAUTIFUL       WORLD!"
    private string NormalizeWhitespace(string inputStr)
    {
    //First split the string on the spaces but exclude the spaces themselves
    //Using the input string the length of the array will be 3. If the spaces
    //were not filtered out they would be included in the array
    var splitParts = inputStr.Split(' ').Where(x => x != "").ToArray();
    //Now iterate over the parts in the array and add them to the return
    //string. If the current part is not the last part, add a space after.
    for (int i = 0; i < splitParts.Count(); i++)
    {
    retVal += splitParts[i];
    if (i != splitParts.Count() - 1)
    {
    retVal += " ";
    }
    }
    return retVal;
    }
    //Would return "HELLO BEAUTIFUL WORLD!"

    Sé que estoy creando una segunda cadena de aquí para devolverlo así como la creación de la splitParts matriz. Se dio cuenta de que esto es bastante sencillo. Tal vez yo no soy de tomar en cuenta algunos de los posibles escenarios.

  19. 1

    Sé que esto es muy antiguo, pero la manera más fácil de compactar el espacio en blanco (reemplazar cualquier periódico carácter de espacio en blanco con un único carácter de «espacio») es como sigue:

        public static string CompactWhitespace(string astring)
    {
    if (!string.IsNullOrEmpty(astring))
    {
    bool found = false;
    StringBuilder buff = new StringBuilder();
    foreach (char chr in astring.Trim())
    {
    if (char.IsWhiteSpace(chr))
    {
    if (found)
    {
    continue;
    }
    found = true;
    buff.Append(' ');
    }
    else
    {
    if (found)
    {
    found = false;
    }
    buff.Append(chr);
    }
    }
    return buff.ToString();
    }
    return string.Empty;
    }
    • Por supuesto, usted puede utilizar la misma lógica dentro de un ciclo «for» en su lugar, por un ligero aumento de rendimiento (ya que C# no necesitamos crear una instancia de un enumerador que el «foreach» bucle requiere)
  20. 1
    public static string RemoveExtraSpaces(string input)
    {
    input = input.Trim();
    string output = "";
    bool WasLastCharSpace = false;
    for (int i = 0; i < input.Length; i++)
    {
    if (input[i] == ' ' && WasLastCharSpace)
    continue;
    WasLastCharSpace = input[i] == ' ';
    output += input[i];
    }
    return output;
    }
  21. 1

    Para aquellos que sólo quieren copiar-pase y vaya a:

        private string RemoveExcessiveWhitespace(string value)
    {
    if (value == null) { return null; }
    var builder = new StringBuilder();
    var ignoreWhitespace = false;
    foreach (var c in value)
    {
    if (!ignoreWhitespace || c != ' ')
    {
    builder.Append(c);
    }
    ignoreWhitespace = c == ' ';
    }
    return builder.ToString();
    }
  22. 1

    No estoy muy familiarizado con C#, por lo tanto mi código no es un elegante/más eficaz. Yo he venido aquí para encontrar una respuesta que se ajusta a mi caso de uso, pero no pude encontrar uno (o yo no podía entender por uno).

    Para mi caso, yo necesarios para normalizar todos los Espacios en Blanco (WS: {space, tab, cr lf}), con las siguientes condiciones:

    • WS puede venir en cualquier combinación
    • Reemplazar una secuencia de revés por el LR con los más importantes WS
    • tab necesita para conservarse en algunos casos (un archivo separado, por ejemplo. y que en caso de repetirse las pestañas también necesitan ser conservados). Pero en la mayoría de los casos tienen que ser convertidos en espacios.

    Así que aquí se muestra un ejemplo de entrada y una de salida esperada (Descargo de responsabilidad: mi código de una prueba sólo para este ejemplo)

    
    Every night    in my            dreams  I see you, I feel you
    That's how    I know you go on
    Far across the  distance and            places between us   
    You            have                 come                    to show you go on
    

    para ser convertidos en

    Every night in my dreams I see you, I feel you
    That's how I know you go on
    Far across the distance and places between us
    You have come to show you go on

    Aquí está mi código

    using System;
    using System.Text.RegularExpressions;
    public class Program
    {
    public static void Main(string text)
    {
    bool preserveTabs = false;
    //[Step 1]: Clean up white spaces around the text
    text = text.Trim();
    //Console.Write("\nTrim\n======\n" + text);
    //[Step 2]: Reduce repeated spaces to single space. 
    text = Regex.Replace(text, @" +", " ");
    //Console.Write("\nNo repeated spaces\n======\n" + text);
    //[Step 3]: Hande Tab spaces. Tabs needs to treated with care because 
    //in some files tabs have special meaning (for eg Tab seperated files)
    if(preserveTabs)
    {
    text = Regex.Replace(text, @" *\t *", "\t");
    }
    else
    {
    text = Regex.Replace(text, @"[ \t]+", " ");
    }
    //Console.Write("\nTabs preserved\n======\n" + text);
    //[Step 4]: Reduce repeated new lines (and other white spaces around them)
    //into a single new line.
    text = Regex.Replace(text, @"([\t ]*(\n)+[\t ]*)+", "\n");
    Console.Write("\nClean New Lines\n======\n" + text);    
    }
    }

    Ver este código en acción aquí: https://dotnetfiddle.net/eupjIU

  23. 1

    No sé si es la manera más rápida, pero yo uso este y este se trabajó para mí:

        ///<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();
    }
  24. -1

    No hay necesidad de un código complejo! Aquí es un simple código que se quite los duplicados:

    public static String RemoveCharOccurence(String s, char[] remove)
    {
    String s1 = s;
    foreach(char c in remove)
    {
    s1 = RemoveCharOccurence(s1, c);
    }
    return s1;
    }
    public static String RemoveCharOccurence(String s, char remove)
    {
    StringBuilder sb = new StringBuilder(s.Length);
    Boolean removeNextIfMatch = false;
    foreach(char c in s)
    {
    if(c == remove)
    {
    if(removeNextIfMatch)
    continue;
    else
    removeNextIfMatch = true;
    }
    else
    removeNextIfMatch = false;
    sb.Append(c);
    }
    return sb.ToString();
    }
    • Esto no responde a OP pregunta. Él quiere reemplazar a varios caracteres de espacio en blanco (espacios, tabuladores, nuevas líneas) con un solo «espacio en blanco» – probablemente sólo espacio. El código no se manejar un espacio seguido de una ficha (y otro espacio y/o newline) como era de esperar – no va a sustituir a la secuencia con un solo espacio.
    • Además, esto no es eficiente si usted necesita para eliminar varios caracteres – es necesario que N pasa. Así que esto no es definitivamente la manera más rápida. Si sólo necesita un único carácter de la víctima, a continuación, su 2do método está bien
  25. -1

    Es muy simple, sólo tiene que utilizar el .Replace() método:

    string words = "Hello     world!";
    words = words.Replace("\\s+", " ");

    Output >>> «Hola mundo!»

Dejar respuesta

Please enter your comment!
Please enter your name here