标签: chunking

我一直在寻找一种优雅而有效的方法,将一个字符串块化为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?

你会推荐更好的解决方案吗？

编辑

感谢Jeremy Ruten提供的优雅高效的解决方案:

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

可能重复:
如何在Python中将列表拆分为大小均匀的块？

我很惊讶我找不到一个"批处理"函数,它将输入迭代并返回一个可迭代的迭代.

例如:

for i in batch(range(0,10), 1): print i
[0]
[1]
...
[9]

要么:

for i in batch(range(0,10), 3): print i
[0,1,2]
[3,4,5]
[6,7,8]
[9]

现在,我写了一个我认为非常简单的生成器:

def batch(iterable, n = 1):
   current_batch = []
   for item in iterable:
       current_batch.append(item)
       if len(current_batch) == n:
           yield current_batch
           current_batch = []
   if current_batch:
       yield current_batch

但上面没有给我我所期望的:

for x in   batch(range(0,10),3): print x
[0]
[0, 1]
[0, 1, 2]
[3]
[3, 4]
[3, 4, 5]
[6]
[6, 7]
[6, 7, 8]
[9] …

我的确切方案是批量插入数据库,所以我想累积DOM对象然后每1000个,刷新它们.

我通过将代码放入累加器来检测丰满度然后刷新来实现它,但这似乎是错误的 - 刷新控件应该来自调用者.

我可以将流转换为List然后以迭代方式使用subList,但这似乎也很笨拙.

有一个简洁的方法来处理每n个元素然后继续流,而只处理流一次？

我有一个大文本文件(约7 GB).我正在寻找是否存在阅读大文本文件的最快方法.我一直在阅读有关使用多种方法作为读取chunk-by-chunk以加快进程的过程.

例如,effbot建议

# File: readline-example-3.py

file = open("sample.txt")

while 1:
    lines = file.readlines(100000)
    if not lines:
        break
    for line in lines:
        pass # do something**strong text**

为了每秒处理96,900行文本.其他作者建议使用islice()

from itertools import islice

with open(...) as f:
    while True:
        next_n_lines = list(islice(f, n))
        if not next_n_lines:
            break
        # process next_n_lines

list(islice(f, n))将返回n文件的下一行列表f.在循环中使用它将为您提供大量n行的文件

我正在使用自定义API来允许用户上传文件(希望是任意大小).如果文件很大,它将被chunkfied,并在对服务器的多个请求中处理.

我正在编写使用File和FileReader(HTML5)的代码,根据许多在线示例.一般来说(从我在网上看到的)对于一个chunkfied文件传输,人们将首先从他们的文件对象中获取一大块数据

var file = $('input[type=file]')[0].files[0];
var blob = file.slice(start,end)

然后使用a FileReader来读取blob readAsArrayBuffer(blob)或readAsBinaryString(blob)

最后在FileReader.onload(e)方法中,将数据发送到服务器.对文件中的所有块重复此过程.

我的问题是

为什么我需要使用FileReader？如果我不使用它,并简单地发送blob File.slice,是否有任何保证在我尝试在每个请求中发送数据之前完成切片操作.File对象是否在创建时加载整个文件(当然不是？).是否File.slice寻求参数规定的位置,然后读取信息？该文档没有给我一个关于它如何实现的线索.

我正在为透明代理编写HTTP解析器.什么让我感到困惑的是Trailer:规格中提到的Transfer-Encoding: chunked.它是什么样子的？

通常,HTTP chunked会像这样结束.

0\r\n
\r\n

我感到困惑的是如果有某种尾随标题,如何检测块的结尾...

更新:我相信一个简单的\r\n\r\n即空行足以检测尾随标题的结尾......这是正确的吗？

我需要一种方法来在asp.net mvc网站上传大文件(600 mb到4 gb).目前我正在使用swfupload ; 它运行得很好,但它在网络服务器上受到了极大的打击,因为它在一个大的上传中发送它,而且我必须在web.config中设置它以允许大量的文件,这是一个巨大的安全风险.在我以前进行Web表单开发时,我使用了Neatupload,它将文件分成块并单独上传.我正在寻找一种方法来上传mvc中的大文件,通过分块上传.有关如何做到这一点的任何想法？

我有一个懒惰ByteString的函数,我希望有严格的ByteStrings返回列表(懒惰应该转移到输出的列表类型).

import qualified Data.ByteString as B
import qualified Data.ByteString.Lazy as L
csVals :: L.ByteString -> [B.ByteString]

我想因各种原因这样做,有几个lexing函数需要严格的ByteStrings,我可以保证ByteStrings输出中csVal的输出严格s 非常小.

如何在ByteString没有分块的情况下进行"严格化" ？

Update0

我想采取一个懒惰ByteString,并使一个严格ByteString包含其所有数据.

我有一个案例,我需要使用wsHttp使用WCF 传输大量的序列化对象图(通过NetDataContractSerializer).我正在使用邮件安全性,并希望继续这样做.使用这个设置我想传输序列化的对象图,有时可以接近300MB左右但是当我尝试这样做时,我开始看到System.InsufficientMemoryException类型的异常出现.

经过一些研究后,默认情况下,WCF中默认情况下,服务调用的结果默认包含在单个消息中,其中包含序列化数据,并且默认情况下在服务器上缓冲此数据,直到完整写入整个消息.因此,内存异常是由于服务器的内存资源不足而导致分配的,因为该缓冲区已满.我遇到的两个主要建议是使用流式传输或分块来解决这个问题,但是我不清楚这涉及到什么,以及我的当前设置是否可以使用任何解决方案(wsHttp/NetDataContractSerializer/Message Security).到目前为止,我理解使用流式消息安全性不起作用,因为消息加密和解密需要处理整个数据集而不是部分消息.然而,Chunking听起来似乎有可能,但是我不清楚如何使用我列出的其他约束来完成它.如果有人可以就可用的解决方案以及如何实施它提供一些指导,我将非常感激.

我应该补充一点,在我的情况下,我真的不担心与其他客户端的互操作性,因为我们拥有并控制通信的每一面,并使用共享接口模式传输到任何一方的数据.所以我愿意接受任何符合使用带有消息安全性的wsHttp以转移使用NetDataContractSerializer序列化的对象图的约束的想法,我更喜欢一个解决方案,我不需要大幅改变我现有的服务和周围的基础设施.

相关资源:

• 分块通道
• 如何:启用流式传输
• WCF上的大型附件
• 自定义消息编码器
• 另一个发现InsufficientMemoryException
• 需要非双工分块通道
• 使用WCF和延迟执行流式传输大型内容

我也对可以对这些数据进行的任何类型的压缩感兴趣,但看起来我可能最好在传输级别执行此操作,一旦我可以转换到.NET 4.0,以便客户端将自动支持gzip标题如果我理解正确的话.

更新(2010-06-29):

关于如何在结论中得出缓冲消息太大导致我的问题的一些历史.最初我在测试时看到了下面的CommunicationException.

底层连接已关闭:连接意外关闭.

最后,在运行此操作并进行更多日志记录后,我发现了导致指定消息出现问题的基础InsufficientMemoryException异常.

无法分配268435456字节的托管内存缓冲区.可用内存量可能很低.

其中源于以下方法.

System.ServiceModel.Diagnostics.Utility.AllocateByteArray(Int32 size)

所以在其他方面,失败来自分配阵列.当写入序列化到磁盘的相同数据时,它需要大约146MB,如果我将其减少一半,那么我就会停止获取错误但是我没有更多地挖掘破坏我的缓冲区的特定阈值以及它是否特定于我的系统或不.

更新(2010-12-06):

我想在这一点上我正在为以下内容寻找一些澄清.我的理解是,默认情况下WCF wsHttp具有消息安全性,在响应被发送回客户端之前需要在服务器上缓冲整个消息(通常是我正在返回的整个数据集),从而导致我的问题.

可能的解决方案:

• 约束数据大小 - 通过使用某种形式的压缩,编码或限制通过使用某种类型的分页方法返回的实际数据,以避免消耗传出缓冲区的最大容量.
• 流 - 允许以流方式通过WCF发送大量数据,但这与wsHttp或MessageSecurity不兼容,因为这些技术需要缓冲所有数据.
• 分块通道 - 允许将数据分解为单独的消息,但此时我不确定这对服务合同设计的限制以及我是否仍然可以将wsHttp与消息绑定结合使用.

限制我可以返回的数据只能达到某一点,并且与Streaming选项一样,这些选项需要在WCF服务调用之外编写许多较低级别的工作.所以我想我需要知道的是,通过允许将一组数据分解为服务器上的单独消息然后在客户端上拼凑在一起,是否任何可能的分块通道实现都可以解决大型消息问题.这样一种方式,我不必改变现有服务合同的接口/形状,并且在仍然使用消息安全性和wsHttp的同时,几乎隐藏了每个服务实现的客户端和服务器部分的过程.如果分块通道要求我重新编写我的服务合同以暴露流,那么我不会 看看这与Streaming解决方案有什么不同.如果有人可以简单地为我回答这些问题,我会给予奖励,并将其标记为答案.

我的印象是懒惰的seqs总是被分块.

=> (take 1 (map #(do (print \.) %) (range)))
(................................0)

正如预期的那样打印32个点,因为返回的lazy seq range被分成32个元素块.但是,当range我用自己的函数尝试这个时get-rss-feeds,懒惰的seq不再是分块的:

=> (take 1 (map #(do (print \.) %) (get-rss-feeds r)))
(."http://wholehealthsource.blogspot.com/feeds/posts/default")

只打印了一个点,所以我猜测返回的lazy-seq get-rss-feeds没有分块.确实:

=> (chunked-seq? (seq (range)))
true

=> (chunked-seq? (seq (get-rss-feeds r)))
false

以下是来源get-rss-feeds:

(defn get-rss-feeds
  "returns a lazy seq of urls of all feeds; takes an html-resource from the enlive library"
  [hr]
  (map #(:href (:attrs %))
       (filter #(rss-feed? (:type (:attrs %))) (html/select hr [:link])))

因此,看起来粗糙取决于懒惰的seq是如何产生的.我偷看了函数的来源,range …