在 Scala 中编写 read-while 循环的正确方法是什么？

Question

在 Scala 中编写标准 read-while 循环的“正确”是什么？我所说的“正确”是指以类似 Scala 的方式编写，而不是类似 Java 的方式。

这是我在 Java 中的代码：

MessageDigest md = MessageDigest.getInstance( "MD5" );
InputStream input = new FileInputStream( "file" );
byte[] buffer = new byte[1024];
int readLen;
while( ( readLen = input.read( buffer ) ) != -1 )
    md.update( buffer, 0, readLen );
return md.digest();

这是我在 Scala 中的代码：

val md = MessageDigest.getInstance( hashInfo.algorithm )
val input = new FileInputStream( "file" )
val buffer = new Array[ Byte ]( 1024 )
var readLen = 0
while( readLen != -1 )
{
    readLen = input.read( buffer )
    if( readLen != -1 )
        md.update( buffer, 0, readLen )
}
md.digest

Scala 代码是正确的并且可以工作，但感觉非常不 Scala 风格。其一，它是 Java 代码的直译，没有利用 Scala 的任何优点。而且它实际上比 Java 代码还要长！我真的感觉自己失去了一些东西，但又想不起来到底是什么。

我对 Scala 相当陌生，所以我问这个问题是为了避免陷入在 Scala 中编写 Java 风格代码的陷阱。我对解决此类问题的 Scala 方法更感兴趣，而不是 Scala API 可能提供的用于散列文件的任何特定帮助程序方法。

（对于我在这个问题中使用的临时 Scala 形容词，我提前表示歉意。）

Answer 1

根据 Rex 的帖子，他提到：

Stream.continually(input.read(buffer)).takeWhile(_ != -1).foreach(md.update(buffer, 0, _))

您应该替换 var readLen + while {...} 行，它会产生相同的结果。

正如 Rex 提到的，它适用于 scala 2.8。

Answer 2

Rex Kerr 在他的评论中建议如下：

val md = MessageDigest.getInstance("MD5")
val input = new FileInputStream("foo.txt")
val buffer = new Array[ Byte ]( 1024 )
Stream.continually(input.read(buffer))
  .takeWhile(_ != -1)
  .foreach(md.update(buffer, 0, _))
md.digest

关键是 Stream.continually。它获取一个不断求值的表达式，创建一个求值表达式的无限Stream。 takeWhile 是 while 条件的转换。 foreach 是 while 循环的主体。

Answer 3

柯里化函数怎么样？您的 11 行 Scala 代码变为：

val md = MessageDigest.getInstance(hashInfo.algorithm)
val input = new FileInputStream("file")
iterateStream(input){ (data, length) => 
    md.update(data, 0, length)
}
md.digest

第 3 行的 iterateStream 函数，您可以将其添加到库中：

def iterateStream(input: InputStream)(f: (Array[Byte], Int) => Unit){
    val buffer = new Array[Byte](512)
    var curr = input.read(buffer)
    while(curr != -1){
        f(buffer, curr)
        curr = input.read(buffer)
    }
}

丑陋的重复代码（读取输入的位置）最终出现在库中，经过充分测试并且远离程序员。我觉得第一段代码比 Iterator.continually 解决方案简单。