Scala 新手眼中的十种有趣用法[转]

scala

转载 https://n3xtchen.github.io/n3xtchen/scala/2016/06/15/scala-top-10-for-new

作为一个初学者，经过一个月系统的系统学习，用惯了动态语言的我来说，Scala 编译器型语言的编程体验真的是太棒了。作为阶段性的总结，我将给出我对 Scala 最佳初体验的 Top 10。

1 漂亮的操作系统调用方式

Scala 2.9里也提供类似功能：新增加了package: scala.sys 及scala.sys.process, 这些代码最初由 SBT (a simple build tool for Scala)项目贡献，主要用于简化与操作系统进程的交互与调用。

现在看看用法：

scala> import scala.language.postfixOps
import scala.language.postfixOps
scala> import scala.sys.process._
import scala.sys.process._
scala> "java -version" !
java version "1.7.0_80"
Java(TM) SE Runtime Environment (build 1.7.0_80-b15)
Java HotSpot(TM) 64-Bit Server VM (build 24.80-b11, mixed mode)
res2: Int = 0

当你引入 scala.sys.process 后，scala 会为你给字符串或数组动态注入 ! 方法来调用系统命令。这是我见过调用 shell 最爽最优雅的方式之一，不是吗？现在看个复杂点的例子，爬取一个页面：

scala> import java.io.File
import java.io.File
scala> import java.net.URL
import java.net.URL
scala> new URL("http://www.scala-lang.org/") #> new File("scala-lang.html") !
res4: Int = 0

这里我们又学到一个新的操作符 #>，结果重定向。这条命令等价于如下 Bash：

$ curl "http://www.scala-lang.org/ > scala-lang.html

看看结果:

scala> "ls" !
...
scala-lang.html
...
res6: Int = 0

参考: http://www.scala-lang.org/api/rc2/scala/sys/process/package.html

2 管道（Pipeline）

scala> import scala.language.implicitConversions
import scala.language.implicitConversions
scala> object Pipeline {
     |   implicit class toPiped[V](value:V) {
     |     def |>[R] (f : V => R) = f(value)
     |   }
     | }
defined module Pipeline
scala> import Pipeline._
import Pipeline._
scala> 1 |> ((i:Int)=> i*10)
res3: Int = 10

这样就可以将，函数返回的值作为后面函数参数，一条链式调用看起来是那么的优雅（你觉得呢？）。

短短几行的代码，足以让你领教到隐式转化（implicit）的威力吧！因为这个话题比较大，就不在这里作详细阐述了。

3 使用 {...} 替代 (...) 的语法糖

声明一个多参数表函数，如下

scala> def m[A](s: A)(f: A=> String) = f(s)
m: [A](s: A)(f: A => String)String

你可以这样调用它：

scala> m(100)(i => s"$i + $i")
res2: String = 100 + 100

你可以使用 {...} 替代 (...) 的语法糖，就可以把上面改写成下面的模式

scala> m(100){ i => s"$i + $i" }
res3: String = 100 + 100

竟然可以如此优雅优雅地调用函数，看起来就像标准的块代码（像 if 和 for 表达式）

4 创建自己的字符解释器

import scala.util.parsing.json._
object Interpolators {
  implicit class jsonForStringContext(val sc: StringContext) {
    def json(values: Any*): JSONObject = {
        val keyRE = """^[\s{,]*(\S+):\s*""".r
        val keys = sc.parts map {
            case keyRE(key) => key
            case str => str
        }
        val kvs = keys zip values
        JSONObject(kvs.toMap)
    }
  }
}
import Interpolators._
val name = "Dean Wampler"
val book = "Programming Scala, Second Edition"
val jsonobj = json"{name: $name, book: $book}" 
println(jsonobj)

5 中缀表达法

在大部分情况下，中缀(Infix)标记和后缀(Postfix)标记可省略：1 + 2
这段语句大家再熟悉不过了，但是在 Scala 中，所有的表达式都是方法，实际上完整的写法，如下：1.+(2)，即，+ 是整型对象（在 Scala 中，一切都是对象）的一个方法，如果了解到这里，会不会觉得能写成之前的样子很神奇。这里是 Scala 一个特性：

如果一个对象有一个带有一个参数的方法，它的中缀标记可以省略，在这里，点号和括号都可以省略。类似的，如果一个方法没有参数表，你调用它的时候，可以它的后缀标记（即括号）可以省略：

scala> 1 toString   // 1.toString()
warning: there were 1 feature warning(s); re-run with -feature for details
res2: String = 1

因为忽略后缀，有时候会让人很迷惑，方法？属性？傻傻分不清楚！所以在版本 2.10 之后，如果没有明确告诉编译器的话，会给出一个警告：

scala> import scala.language.postfixOps
scala> 1 toString
res2: String = 1

警报解除，神奇吧？现在我们看一个复杂的例子：

def isEven(n: Int) = (n % 2) == 0
List(1, 2, 3, 4) filter isEven foreach println
// 等同于 .filter(isEven).foreach(println)

6 简便的类声明：

Java 党可以看过来，不论是 IDE 和文本编辑器党，代码中到处充斥着大量的 setter 和 getter：

// src/main/java/progscala2/basicoop/JPerson.java
package progscala2.basicoop;
public class JPerson {
  private String name;
  private int    age;
  public JPerson(String name, int age) {
    this.name = name;
    this.age  = age;
  }
  public void   setName(String name) { this.name = name; }
  public String getName()            { return this.name; }
  public void setAge(int age) { this.age = age;  }
  public int  getAge()        { return this.age; }
}

看看，Scala 可以这么写：

class Person(var name: String, var age: Int)

有没有像流泪的感觉，哈哈，That is it！如果想要覆盖某些 setter 和 getter，只要类声明中，覆盖相应方法即可。有 var，自然有 val，如果你的对象属性都是不可变，那还可以使用如下声明：

case class Person(name: String, age: Int)

用 Java 的同学会不会很心动啊？^_^

7 密封类型

密封类型（Sealed）强制其子类只能定义在同一个文件中，seals 关键字可以用在 class 和 trait 上。第一个作用如题，举个栗子，Scala 源码中 List 的实现用到 sealed 关键字:

scala> class NewList extends List
<console>:7: error: illegal inheritance from sealed class List
       class NewList extends List

这样子，妈妈再也不用担心我的类被人滥用。如果就这么个功能，怎么能称得上 Top 10 呢？在看一个黑魔法：

scala> sealed abstract class Drawing
defined class Drawing
scala> case class Point(x: Int, y: Int) extends Drawing
defined class Point
scala> case class Circle(p: Point, r: Int) extends Drawing
defined class Circle
scala> case class Cylinder(c: Circle, h: Int) extends Drawing
defined class Cylinder

如果你如之前，少写了其中一個案例：

scala> def what(d: Drawing) = d match {
     |     case Point(_, _)    => "点"
     |     case Cylinder(_, _) => "柱"
     | }
<console>:14: warning: match may not be exhaustive.
It would fail on the following input: Circle(_, _)
       def what(d: Drawing) = d match {
                              ^
what: (d: Drawing)String

编译器在告訴你，有些模式的类型你沒有列在 match 運算式的案例串（Case sequence）之中。你应该每個都列出來才合理：

scala> def what(d: Drawing) = d match {
     |     case Point(_, _)    => "点"
     |     case Circle(_, _)   => "圆"
     |     case Cylinder(_, _) => "柱"
     | }
what: (d: Drawing)String

有時候，你使用別人密封過的案例类别，但也許你真的只想比对其中几個案例类型，如果不想要编译器饶人的警告，则可以在最后使用万用字元模式（_），例如：

scala> def what(d: Drawing) = d match {
     |     case Point(_, _)    => "點"
     |     case Cylinder(_, _) => "柱"
     |     case _              => "" // 作你想作的事，或者丟出例外
     | }
what: (d: Drawing)String

如果你真心不想要使用万用字元作额外处理，那么还可以可以使用 @unchecked 标注來告訴编译器住嘴：

scala> def what(d: Drawing) = (d: @unchecked) match {
     |     case Point(_, _)    => "點"
     |     case Cylinder(_, _) => "柱"
     | }
what: (d: Drawing)String

参考：http://openhome.cc/Gossip/Scala/SealedClass.html

8 有趣的权限控制 private[]

protected 或 private 這表示权限限制到 x 的范围。

class Some {
    private val x = 10
    def doSome(s: Some) = s.x + x
}

对于大多数语言，访问控制就严格无非就这两种。在 Scala 中，可以更加严格，让 x 完全无法透过实例存取，则可以使用 private[this]，這表示私有化至 this 实例本身才可以存取，也就是所謂物件私有（Object-private），例如以下就通不過编译了：

class Some {
    private[this] val x = 10
    def doSome(s: Some) = s.x + x  // 编译错误
}

作为入门，就知道这里就可以了，可以跳到下一个话题了！

如果你看过 Spark（一个分布式计算框架）的源码，会发现这样的权限控制符到处都是，所以这个还是有必要搞清楚的。

如果能看懂下面这段代码，那你对 Scala 的域访问控制算是了解了：

package scopeA {
  class Class1 {
    private[scopeA]   val scopeA_privateField = 1
    protected[scopeA] val scopeA_protectedField = 2
    private[Class1]   val class1_privateField = 3
    protected[Class1] val class1_protectedField = 4
    private[this]     val this_privateField = 5
    protected[this]   val this_protectedField = 6
  }
  class Class2 extends Class1 {
    val field1 = scopeA_privateField
    val field2 = scopeA_protectedField
    val field3 = class1_privateField     // ERROR
    val field4 = class1_protectedField
    val field5 = this_privateField       // ERROR
    val field6 = this_protectedField
  }
}
package scopeB {
  class Class2B extends scopeA.Class1 {
    val field1 = scopeA_privateField     // ERROR
    val field2 = scopeA_protectedField
    val field3 = class1_privateField     // ERROR
    val field4 = class1_protectedField
    val field5 = this_privateField       // ERROR
    val field6 = this_protectedField
  }
}

不懂也没关系，后面会花一个大篇幅来讲这块内容。

9 类型擦除和 implicit

scala> :paste
object M {
  def m(seq: Seq[Int]): Unit = println(s"Seq[Int]: $seq")
  def m(seq: Seq[String]): Unit = println(s"Seq[String]: $seq")
}
<ctrl-d>
<console>:8: error: double definition:
method m:(seq: Seq[String])Unit and
method m:(seq: Seq[Int])Unit at line 7
have same type after erasure: (seq: Seq)Unit
       def m(seq: Seq[String]): Unit = println(s"Seq[String]: $seq")

由于历史原因，JVM 忘记了参数化类型的参数类型。例如例子中的 Seq[Int] 和 Seq[String]，JVM 看到的只是 Seq，而附加的参数类型对于 JVM 来说是不可见，这就是传说中的类型擦除。于是乎，从 JVM 的视角来看，代码是这样子的：

object M {
  // 两者都是接受一个 Seq 参数，返回Unit
  def m(seq: Seq): Unit = println(s"Seq[Int]: $seq")
  def m(seq: Seq): Unit = println(s"Seq[String]: $seq")
}

这不就报错了吗？重复定义方法。那怎么办呢？（JAVA 语言的痛点之一）Scala 给你提供一种比较优雅的解决方案，使用隐式转换：

scala> :paste
object M {
    implicit object IntMarker 
    implicit object StringMarker
    // 对于 JVM 来说是，接受 Seq 参数和 IntMarker.type 型 i 参数，
    // 返回 Unit
    def m(seq: Seq[Int])(implicit i: IntMarker.type): Unit =
println(s"Seq[Int]: $seq")
    // 对于 JVM 来说是，接受 Seq 参数和 StringMarker.type 型 i 参数，
    // 返回 Unit
    // 
    def m(seq: Seq[String])(implicit s: StringMarker.type): Unit =
println(s"Seq[String]: $seq")
}
<ctrl-d>
scala> import M._
scala> m(List(1,2,3))   // 在调用的时候，忽略隐式类型
scala> m(List("one", "two", "three"))

10 异常捕捉与 Scalaz

先来看看，异常捕捉语句：

try {
    source = Some(Source.fromFile(fileName))
    val size = source.get.getLines.size
    println(s"file $fileName has $size lines")
} catch {
    case NonFatal(ex) => println(s"Non fatal exception! $ex")
} finally {
  for (s <- source) {
    println(s"Closing $fileName...")
    s.close
  }
}

这里是打开文件的操作，并且计算行数；NonFatal 非致命错误，如内存不足之类的非致命错误，将会被抛掉。finnaly 操作结束后，关闭文件。这是 Scala 模式匹配的又一大应用场景，你会发现倒是都是模式匹配：

case NonFatal(ex) => ...

如果每条异常的处理语句只是单条的话，Scala 写起来应该会挺爽的。

在传统的异常处理，无法一次性汇总运行过程中的错误。如果我们在做表单验证的时候，我们就需要考虑到这个场景。而传统的做法就是通过一层层 try ... catch ...，把错误追加到一个列表中来实现，而 scalaz 中提供一个适用于这个场景的封装，直接看例子吧：

import scalaz._, std.AllInstances._
/* 验证用户名，非空和只包含字母 */
def validName(key: String, name: String):
    Validation[List[String], List[(String,Any)]] = {
  val n = name.trim  // remove whitespace
  if (n.length > 0 && n.matches("""^\p{Alpha}$""")) Success(List(key -> n))
  else Failure(List(s"Invalid $key <$n>"))
} 
/* 验证数字，并且大于0 */
def positive(key: String, n: String):
    Validation[List[String], List[(String,Any)]] = {
  try {
    val i = n.toInt
    if (i > 0) Success(List(key -> i))
    else Failure(List(s"Invalid $key $i"))
  } catch {
    case _: java.lang.NumberFormatException =>
      Failure(List(s"$n is not an integer"))
  }
}
/* 验证表单 */
def validateForm(firstName: String, lastName: String, age: String):
    Validation[List[String], List[(String,Any)]] = {
  validName("first-name", firstName) +++ validName("last-name", lastName) +++
    positive("age", age)
}
validateForm("Dean", "Wampler", "29")
validateForm("", "Wampler", "0")
// Returns: Failure(List(Invalid first-name <>, Invalid age 0))
//告知你名字和年龄填写有误
validateForm("Dean", "", "0") 
// Returns: Failure(List(Invalid last-name <>, Invalid age 0)) 
// 告知你姓氏和年龄填写有误
validateForm("D e a n", "", "29")
// Returns: Failure(List(Invalid first-name <D e a n>, Invalid last-name <>)) 
// 告知你名字和姓氏填写错误