Qual è il modo migliore per tagliare una stringa in pezzi di una data lunghezza in Ruby?

Ho cercato un modo elegante ed efficiente per suddividere una stringa in sottostringhe di una determinata lunghezza in Ruby.

Finora, il meglio che sono riuscito a trovare è questo:

def chunk(string, size)
  (0..(string.length-1)/size).map{|i|string[i*size,size]}
end

>> chunk("abcdef",3)
=> ["abc", "def"]
>> chunk("abcde",3)
=> ["abc", "de"]
>> chunk("abc",3)
=> ["abc"]
>> chunk("ab",3)
=> ["ab"]
>> chunk("",3)
=> []

Potresti voler chunk("", n)tornare [""]invece di []. In tal caso, aggiungilo come prima riga del metodo:

return [""] if string.empty?

Consiglieresti una soluzione migliore?

modificare

Grazie a Jeremy Ruten per questa soluzione elegante ed efficiente: [modifica: NON efficiente!]

def chunk(string, size)
    string.scan(/.{1,#{size}}/)
end

modificare

La soluzione string.scan impiega circa 60 secondi per tagliare 512k in blocchi da 1k 10000 volte, rispetto alla soluzione originale basata su slice che richiede solo 2,4 secondi.

Usa String#scan:

>> 'abcdefghijklmnopqrstuvwxyz'.scan(/.{4}/)
=> ["abcd", "efgh", "ijkl", "mnop", "qrst", "uvwx"]
>> 'abcdefghijklmnopqrstuvwxyz'.scan(/.{1,4}/)
=> ["abcd", "efgh", "ijkl", "mnop", "qrst", "uvwx", "yz"]
>> 'abcdefghijklmnopqrstuvwxyz'.scan(/.{1,3}/)
=> ["abc", "def", "ghi", "jkl", "mno", "pqr", "stu", "vwx", "yz"]

Ecco un altro modo per farlo:

"abcdefghijklmnopqrstuvwxyz".chars.to_a.each_slice(3).to_a.map {|s| s.to_s }

=> ["abc", "def", "ghi", "jkl", "mno", "pqr", "stu", "vwx", "yz"]

Penso che questa sia la soluzione più efficiente se sai che la tua stringa è un multiplo della dimensione del blocco

def chunk(string, size)
    (string.length / size).times.collect { |i| string[i * size, size] }
end

e per parti

def parts(string, count)
    size = string.length / count
    count.times.collect { |i| string[i * size, size] }
end

Ecco un'altra soluzione per casi leggermente diversi, quando si elaborano stringhe di grandi dimensioni e non è necessario memorizzare tutti i blocchi contemporaneamente. In questo modo memorizza un singolo blocco alla volta e si comporta molto più velocemente dello slicing delle stringhe:

io = StringIO.new(string)
until io.eof?
  chunk = io.read(chunk_size)
  do_something(chunk)
end

Ho fatto un piccolo test che taglia circa 593 MB di dati in 18991 pezzi da 32 KB. La tua versione slice + map è stata eseguita per almeno 15 minuti utilizzando il 100% della CPU prima di premere ctrl + C. Questa versione che utilizza String # unpack è terminata in 3,6 secondi:

def chunk(string, size)
  string.unpack("a#{size}" * (string.size/size.to_f).ceil)
end

test.split(/(...)/).reject {|v| v.empty?}

Il rifiuto è necessario perché altrimenti include lo spazio vuoto tra le serie. La mia regex-fu non è del tutto in grado di vedere come risolverlo direttamente dalla cima della mia testa.

Una soluzione migliore che tiene conto dell'ultima parte della stringa che potrebbe essere inferiore alla dimensione del chunk:

def chunk(inStr, sz)  
  return [inStr] if inStr.length < sz  
  m = inStr.length % sz # this is the last part of the string
  partial = (inStr.length / sz).times.collect { |i| inStr[i * sz, sz] }
  partial << inStr[-m..-1] if (m % sz != 0) # add the last part 
  partial
end

Ci sono altri vincoli che hai in mente? Altrimenti sarei terribilmente tentato di fare qualcosa di semplice come

[0..10].each {
   str[(i*w),w]
}

text.scan(/.{1,4}/m)Risolve solo il problema