Який найкращий спосіб рубати струну на шматки заданої довжини в Ruby?

Я шукав елегантний та ефективний спосіб розділити рядок на підрядки заданої довжини в Ruby.

Поки що найкраще, що я міг придумати, це:

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)
=> []

Можливо, ви захочете chunk("", n)повернутися [""]замість []. Якщо так, просто додайте це як перший рядок методу:

return [""] if string.empty?

Чи не порекомендували б ви краще рішення?

Редагувати

Дякуємо Джеремі Рутену за це елегантне та ефективне рішення: [редагувати: НЕ ефективно!]

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

Редагувати

Рішенню string.scan потрібно приблизно 60 секунд, щоб розділити 512 тис. На 1 тис. Фрагментів 10000 разів, порівняно з оригінальним рішенням на основі зрізів, яке займає лише 2,4 секунди.

Використання 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"]

Ось ще один спосіб зробити це:

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

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

Я думаю, це найефективніше рішення, якщо ви знаєте, що ваш рядок кратний розміру шматка

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

і за частинами

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

Ось ще одне рішення для дещо іншого випадку, коли обробляються великі рядки, і немає необхідності зберігати всі фрагменти одночасно. Таким чином, він зберігає окремі шматки за раз і виконує набагато швидше, ніж нарізання рядків:

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

Я зробив невеликий тест, який розбиває близько 593 МБ даних на 18991 32 КБ. Ваша версія фрагмента + карти працювала принаймні 15 хвилин із використанням 100% процесора, перш ніж я натиснув ctrl + C. Ця версія за допомогою розпакування String # закінчилася за 3,6 секунди:

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

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

Відхилення необхідне, оскільки воно в іншому випадку включає порожній простір між наборами. Мій регулярний вираз-фу не зовсім готовий бачити, як це виправити прямо на маківці.

Краще рішення, яке враховує останню частину рядка, яка може бути меншою за розмір шматка:

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

Чи є деякі інші обмеження, які ви маєте на увазі? В іншому випадку я мав би страшну спокусу зробити щось таке просте, як

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

Просто text.scan(/.{1,4}/m)вирішує проблему