Tách chuỗi trong 512 khối chữ

Question

Có thể là câu hỏi cơ bản nhưng hãy để chúng tôi nói rằng tôi có một chuỗi dài 2000 ký tự, tôi cần chia chuỗi này thành tối đa 512 khối ký tự mỗi khối.

Có cách nào hay, giống như vòng lặp để thực hiện việc này?

Answer 1

Something như thế này:

private IList<string> SplitIntoChunks(string text, int chunkSize) 
{ 
    List<string> chunks = new List<string>(); 
    int offset = 0; 
    while (offset < text.Length) 
    { 
     int size = Math.Min(chunkSize, text.Length - offset); 
     chunks.Add(text.Substring(offset, size)); 
     offset += size; 
    } 
    return chunks; 
} 

Hoặc chỉ để lặp qua:

private IEnumerable<string> SplitIntoChunks(string text, int chunkSize) 
{ 
    int offset = 0; 
    while (offset < text.Length) 
    { 
     int size = Math.Min(chunkSize, text.Length - offset); 
     yield return text.Substring(offset, size); 
     offset += size; 
    } 
} 

Lưu ý rằng đây chia thành nhiều phần của-16 UTF đơn vị mã, đó là không hoàn toàn giống như tách thành các khối mã Unicode, mà lần lượt có thể không giống như tách thành các khối glyph.

Answer 2

static IEnumerable<string> Split(string str, int chunkSize)  
{ 
    int len = str.Length; 
    return Enumerable.Range(0, len/chunkSize).Select(i => str.Substring(i * chunkSize, chunkSize));  
} 

nguồn: Splitting a string into chunks of a certain size

Answer 3

Something như thế nào?

Calculate eachLength = StringLength/WantedCharLength 
Then for (int i = 0; i < StringLength; i += eachLength) 
SubString (i, eachLength); 

Answer 4

tôi sẽ dám để cung cấp một nhiều phiên bản LINQified dung dịch của Jon, dựa trên thực tế là loại string thực hiện IEnumerable<char>:

private IList<string> SplitIntoChunks(string text, int chunkSize) 
{ 
    var chunks = new List<string>(); 
    int offset = 0; 
    while(offset < text.Length) { 
     chunks.Add(new string(text.Skip(offset).Take(chunkSize).ToArray())); 
     offset += chunkSize; 
    } 
    return chunks; 
} 

Answer 5

sử dụng thực hiện của Jon và năng suất từ khóa.

IEnumerable<string> Chunks(string text, int chunkSize) 
{ 
    for (int offset = 0; offset < text.Length; offset += chunkSize) 
    { 
     int size = Math.Min(chunkSize, text.Length - offset); 
     yield return text.Substring(offset, size); 
    } 
} 

Answer 6

Mặc dù câu hỏi này trong khi đó có câu trả lời được chấp nhận, đây là phiên bản ngắn với sự trợ giúp của cụm từ thông dụng. Purists có thể không thích nó (dễ hiểu) nhưng khi bạn cần một giải pháp nhanh chóng và bạn đang thuận tiện với regexes, điều này có thể được nó. Hiệu suất khá tốt, đáng ngạc nhiên:

string [] split = Regex.Split(yourString, @"(?<=\G.{512})"); 

Nó có tác dụng gì? Phủ định ngược lại và nhớ vị trí cuối cùng với \G. Nó cũng sẽ bắt được bit cuối cùng, ngay cả khi nó không thể chia cho 512.

Answer 7

Hầu hết câu trả lời có thể có cùng một lỗi. Với một văn bản trống, chúng sẽ không tạo ra gì cả. Chúng tôi (I) mong đợi ít nhất để lấy lại chuỗi rỗng đó (cùng một hành vi như một sự chia tách trên một char không có trong chuỗi, sẽ trả lại một mục: chuỗi đã cho)

vì vậy chúng ta nên lặp lại ít nhất một lần mọi thời điểm (dựa trên mã của Jon):

IEnumerable<string> SplitIntoChunks (string text, int chunkSize) 
{ 
    int offset = 0; 
    do 
    { 
     int size = Math.Min (chunkSize, text.Length - offset); 
     yield return text.Substring (offset, size); 
     offset += size; 
    } while (offset < text.Length); 
} 

hoặc sử dụng cho (Edited: sau khi đùa giỡn một chút hơn với điều này, tôi tìm thấy một cách tốt hơn để xử lý các trường hợp chunkSize lớn hơn văn bản):

IEnumerable<string> SplitIntoChunks (string text, int chunkSize) 
{ 
    if (text.Length <= chunkSize) 
     yield return text; 
    else 
    { 
     var chunkCount = text.Length/chunkSize; 
     var remainingSize = text.Length % chunkSize; 

     for (var offset = 0; offset < chunkCount; ++offset) 
      yield return text.Substring (offset * chunkSize, chunkSize); 

     // yield remaining text if any 
     if (remainingSize != 0) 
      yield return text.Substring (chunkCount * chunkSize, remainingSize); 
    } 
} 

Đó cũng có thể được sử dụng với việc phải làm/Vòng lặp while;)

Answer 8

phương pháp khuyến nông Generic:

using System; 
using System.Collections.Generic; 
using System.Linq; 

public static class IEnumerableExtensions 
{ 
    public static IEnumerable<IEnumerable<T>> SplitToChunks<T> (this IEnumerable<T> coll, int chunkSize) 
    { 
    int skipCount = 0; 
    while (coll.Skip (skipCount).Take (chunkSize) is IEnumerable<T> part && part.Any()) 
    { 
     skipCount += chunkSize; 
     yield return part; 
    } 
    } 
} 

class Program 
{ 
    static void Main (string[] args) 
    { 
    var col = Enumerable.Range(1,1<<10); 
    var chunks = col.SplitToChunks(8); 

    foreach (var c in chunks.Take (200)) 
    { 
     Console.WriteLine (string.Join (" ", c.Select (n => n.ToString ("X4")))); 
    } 

    Console.WriteLine(); 
    Console.WriteLine(); 

    "Split this text into parts that are fifteen characters in length, surrounding each part with single quotes and output each into the console on seperate lines." 
     .SplitToChunks (15) 
     .Select(p => $"'{string.Concat(p)}'") 
     .ToList() 
     .ForEach (p => Console.WriteLine (p)); 

    Console.ReadLine(); 
    } 
}