Fractionner la chaîne en chaînes plus petites en fonction de la longueur

Question

J'aimerais séparer une chaîne d'une variable de longueur.
Il doit vérifier les limites afin de ne pas exploser lorsque la dernière section de chaîne n'est pas aussi longue ou aussi longue que la longueur. Vous recherchez la version la plus succincte (mais compréhensible).

Exemple:

 string x = "AAABBBCC";
string[] arr = x.SplitByLength(3);
// arr[0] -> "AAA";
// arr[1] -> "BBB";
// arr[2] -> "CC"
 

Answer 1

Vous devez utiliser une boucle:

 public static IEnumerable<string> SplitByLength(this string str, int maxLength) {
    for (int index = 0; index < str.Length; index += maxLength) {
        yield return str.Substring(index, Math.Min(maxLength, str.Length - index));
    }
}
 

Alternative:

 public static IEnumerable<string> SplitByLength(this string str, int maxLength) {
    int index = 0;
    while(true) {
        if (index + maxLength >= str.Length) {
            yield return str.Substring(index);
            yield break;
        }
        yield return str.Substring(index, maxLength);
        index += maxLength;
    }
}
 

2 ^ème alternative: (Pour ceux qui ne supportent pas while(true) )

 public static IEnumerable<string> SplitByLength(this string str, int maxLength) {
    int index = 0;
    while(index + maxLength < str.Length) {
        yield return str.Substring(index, maxLength);
        index += maxLength;
    }

    yield return str.Substring(index);
}
 

Answer 2

Version facile à comprendre:

 string x = "AAABBBCC";
List<string> a = new List<string>();
for (int i = 0; i < x.Length; i += 3)
{
    if((i + 3) < x.Length)
        a.Add(x.Substring(i, 3));
    else
        a.Add(x.Substring(i));
}
 

Bien que de préférence le 3 devrait être un gentil const.

Answer 3

Ce n'est pas particulièrement succinct, mais je pourrais utiliser une méthode d'extension comme celle-ci:

 public static IEnumerable<string> SplitByLength(this string s, int length)
{
    for (int i = 0; i < s.Length; i += length)
    {
        if (i + length <= s.Length)
        {
            yield return s.Substring(i, length);
        }
        else
        {
            yield return s.Substring(i);
        }
    }
}
 

Notez que je retourne un IEnumerable<string> , pas un tableau. Si vous souhaitez convertir le résultat en tableau, utilisez ToArray :

 string[] arr = x.SplitByLength(3).ToArray();
 

Answer 4

Ma solution:

 public static string[] SplitToChunks(this string source, int maxLength)
{
    return source
        .Where((x, i) => i % maxLength == 0)
        .Select(
            (x, i) => new string(source
                .Skip(i * maxLength)
                .Take(maxLength)
                .ToArray()))
        .ToArray();
}
 

En fait, je préfère utiliser List<string> au lieu de string[] .

Answer 5

Voici ce que je ferais:

public static IEnumerable<string> EnumerateByLength(this string text, int length) {
    int index = 0;
    while (index < text.Length) {
        int charCount = Math.Min(length, text.Length - index);
        yield return text.Substring(index, charCount);
        index += length;
    }
}

Cette méthode permettra l'exécution différée (qui n'a pas vraiment d'importance sur est immuable la classe comme string, mais il est intéressant de noter).

Alors si vous voulez une méthode pour remplir un tableau pour vous, vous pourriez avoir:

public static string[] SplitByLength(this string text, int length) {
    return text.EnumerateByLength(length).ToArray();
}

La raison pour laquelle je voudrais aller avec le nom de l' EnumerateByLength plutôt SplitByLength pour le "noyau" de la méthode est qu' string.Split renvoie un string[], donc dans mon esprit il y a la priorité pour les méthodes dont le nom commence par Split de retour des tableaux.

C'est juste moi, si.