如何使这段代码发挥作用？

Question

我编写了一个简单的脚本，用于将 c 样式标识符名称（例如，invoice_number）转换为 java 样式标识符名称（例如，invoiceNumber）。

val files = Vector("file1", "file2")
for (file <- files) {
  val in = io.Source.fromFile(file).mkString
  var out = ""
  var i = 0
  while (i < in.length) {
    val c = in(i)
    if (c == '_') {
      out += in(i + 1).toUpper
      i += 2
    } else {
      out += c
      i += 1
    }
  }
  val writer = new PrintWriter(file + "1")
  writer.write(out)
  writer.flush()
  writer.close()
}

我想知道如何使该代码发挥作用。我想不出任何高阶函数来替换“如果<某些条件>则将 i 增加 2，否则增加 1”逻辑。谢谢。

Answer 1

好的，这是我的方法。

val in = "identifier" :: "invoice_number" :: "some_other_stuff" :: Nil
val out = in map(identifier => {
  val words = identifier.split("_")
  val tail = words.tail.map(_.capitalize)
  (words.head /: tail)(_ + _)
})

println(in)
println(out)

认为它具有合理的功能风格。有趣的是 scala 专家将如何解决这个问题:)

Answer 2

我很抱歉没有使用 Scala，但基本思想应该翻译，所以这是我在 Haskell 中编写基本逻辑的方式：

capitalize :: Char -> String -> String
capitalize '_' (x:xs) = toUpper x:xs
capitalize x xs = x:xs

convertName :: String -> String
convertName = foldr capitalize ""

我们有两个部分：一个函数，当给定下划线时，或者如果给定时，将字符串的第一个字符大写其他任何内容都会将其添加到字符串前面。然后我们只需在输入字符序列的右折叠中使用它，以空字符串作为基本情况。

请注意，Haskell 中的默认字符串是惰性字符序列，而 Scala 中可能不是这种情况，但我希望类似的事情是可能的，因为 Scala 的功能方面来自与 Haskell 相同的受 ML 启发的传统。

---

编辑：顺便说一句，请注意，与许多函数式程序员可能期望的相反，我的实现不是尾递归，这是有意且正确的。相反，它在列表的尾部进行递归调用，并且由于 Haskell 中的数据构造函数让事情变得懒惰，因此每个输出字符都是根据需要生成的，而折叠的其余部分则延迟延迟，并且整个过程在恒定的堆栈空间中运行。最终结果本质上是一个消耗输入流中的元素的迭代循环，但编写得看起来像一个简单的递归函数。

尽管在一般情况下你不会这样做，除了 Haskell、惰性列表/生成器/等。如今在许多语言中都很常见，并且用于转换此类流的“消耗有限数量，处理它，产生输出”的习惯用法与语言无关。

另外，我很感谢 Antoras 和 Luigi Plinge 使用类似的算法编写了 Scala 实现，这帮助我对 Scala 有更好的感觉，而我目前对 Scala 只是暂时熟悉。

Answer 3

另一种解决方案；使用滑动迭代器窗口：

  println(
    (" ".iterator ++ io.Source.fromFile(file)).sliding(2).map {
      s => if (s(0) == '_') s(1).toUpper else s(1)
    }.filter(_ != '_').mkString)

Answer 4

我将 CA McCann 的 Haskell 代码翻译为 Scala：

def capitalize: (Char, Seq[Char]) => Seq[Char] = {
  case ('_', Seq(x, xs @ _*)) => x.toUpper +: xs
  case (c, xs) => c +: xs
}

def convertNumber: String => String =
  _.foldRight(Seq.empty[Char]) { capitalize } mkString

Seq("invoice_number", "ident", "some_other_stuff") map convertNumber foreach println

因为String 是 Scala 中的 IndexedSeq，向其追加内容实际上需要恒定的时间。 Luigi 的代码可以更新为类似的内容：

def capitalize(xs: Seq[Char], ys: Seq[Char]): Seq[Char] = xs match {
  case Seq('_', x, xs @ _*) => capitalize(xs, ys :+ x.toUpper)
  case Seq(x, xs @ _*) => capitalize(xs, ys :+ x)
  case _ => ys
}

def convertNumber(s: String): String =
  capitalize(s, Seq.empty).mkString

Answer 5

我的尾递归刺：

def camel(s: String) = {
  def rec(s: Seq[Char], res: Seq[Char]): String = s match {
    case Nil           => res.reverse.mkString
    case '_' :: x :: t => rec(t, x.toUpper +: res)
    case x :: t        => rec(t, x +: res)
  }
  rec(s.toList, "")
}

println(camel("hay_guise k_thx_bai")) // hayGuise kThxBai

出于某种原因 "string".toSeq 不匹配，但 .toList 匹配；也许有人可以解释为什么。

编辑：或者这也有效：

def camel(s:String) = {
  val it = s.iterator
  it.map {
    case '_' => if(it.hasNext) it.next.toUpper else ""
    case x => x
  }.mkString
}

Answer 6

当然，你可以只使用正则表达式：

import util.matching.Regex.Match

def camel(s: String) = "_(.)".r.replaceAllIn(s, (m: Match) => m.group(1).toUpperCase)

编辑：
或者，如果您使用匿名函数，它会更短一些，并且不需要导入（无点）：

def camel(s: String) = "_(.)".r replaceAllIn (s, _ group 1 toUpperCase)