请注意，已经定义了函数：

scala> val x = "scala is awesome"
x: java.lang.String = scala is awesome

scala> x.reverse
res1: String = emosewa si alacs

但如果你想自己做：

def reverse(s: String) : String =
(for(i <- s.length - 1 to 0 by -1) yield s(i)).mkString

或者（有时候使用until会更好，但在那种情况下可能不会）

def reverse(s: String) : String =
(for(i <- s.length until 0 by -1) yield s(i-1)).mkString

型
此外，请注意，如果使用反向计数（从大到小），则应指定负步长，否则将得到一个空集：

scala> for(i <- x.length until 0) yield i
res2: scala.collection.immutable.IndexedSeq[Int] = Vector()

scala> for(i <- x.length until 0 by -1) yield i
res3: scala.collection.immutable.IndexedSeq[Int] = Vector(16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

这是一个简短的版本

def reverse(s: String) = ("" /: s)((a, x) => x + a)

编辑：或者更短，我们有非常神秘的

def reverse(s: String) = ("" /: s)(_.+:(_))

但我不推荐这里。

您也可以使用递归方法编写这个代码（添加这个代码只是为了好玩）

def reverse(s: String): String = {
  if (s.isEmpty) ""
  else reverse(s.tail) + s.head
}

如om-nom-nom所示，注意by -1（否则你不是在真正迭代，结果将为空）。
它也可以像这样提供给for解析：

def reverse(s: String): String  =
  (for(i <- s.length - 1 to 0 by -1) yield s(i))(collection.breakOut)

reverse("foo")
// String = oof

使用breakOut的好处是，它可以避免像mkString解决方案那样创建中间结构。

• 注意：breakOut利用了CanBuildFrom和构建器，它们是scala 2.8.0中引入的重新设计的集合库的基础的一部分 *

以上所有答案都是正确的，以下是我的看法：

scala> val reverseString = (str: String) => str.foldLeft("")((accumulator, nextChar) => nextChar + accumulator)
reverseString: String => java.lang.String = <function1>

scala> reverseString.apply("qwerty")
res0: java.lang.String = ytrewq

def rev(s: String): String = {
    val str = s.toList
    def f(s: List[Char], acc: List[Char]): List[Char] = s match {
      case Nil => acc
      case x :: xs => f(xs, x :: acc)
    }
    f(str, Nil).mkString
  }

下面是我对字符串反转的解释。

scala> val sentence = "apple"
sentence: String = apple

scala> sentence.map(x => x.toString).reduce((x, y) => (y + x))
res9: String = elppa