Comment couper une chaîne en sous-chaînes de longueur donnée

Question

J'ai une chaîne que je veux couper en un tableau de sous-chaînes de longueur donnée n. Je ne suis pas intéressé par reste (si la longueur de chaîne ne peut pas être divisée par n sans reste)

let ChopString (myString : string) n = 
    let res = 
     seq{ 
      for i = 0 to myString.Length/n - 1 do 
       yield(String.sub myString (i*n) n) 
      }  
     |> Seq.to_array 
    res 

C'est le meilleur que je pouvais faire. Cela me semble moche.

Y at-il une version plus agréable/plus courte de ceci, peut-être sans pour la boucle?

Answer 1

stringInstance.[start..end] est beaucoup plus lisible que String.sub. Voici ce que je suis venu avec:

let chop (input : string) len = 
    seq { for start in 0 .. len .. input.Length/len 
     do yield input.[start..start + len - 1] } 
    |> Seq.to_array 

Ou vous pouvez utiliser:

let chop (input : string) len = 
    Array.init (input.Length/len) (fun index -> 
     let start = index * len 
     input.[start..start + len - 1]) 

Answer 2

Craig Stunz réponse gauche ici qui manque maintenant. Quoi qu'il en soit, il a souligné article about F# qui ont deux fonctions pour la manipulation de chaînes: explode et implode. Ces deux fonctions proviennent de la bibliothèque ML standard. Voici le code:

let rec explode str = 
     let len = String.length str in 
      if len=0 then [] else 
       (String.sub str 0 1) :: explode (String.sub str 1 (len-1)) 

let rec implode lst = match lst with 
         [] -> "" 
         | x1 :: x2 -> x1^implode x2 

explode chaîne de côtelettes dans la liste de chaîne où chaque chaîne est un caractère.
implode fait l'inverse - concatène la liste de chaînes en une chaîne.
Les deux fonctions sont récursives, il serait donc intéressant de comparer les performances.