為Play初學者準備的Scala基礎知識

1 前言

本文的主要目的是為了讓Play Framework的初學者快速了解Scala語言，算是一篇Play Framework的入門前傳吧。
使用PlayFramework可以極大的提高開發效率，但是需要注意，PlayJava入門很簡單，我之前帶過一個實習小姑娘，有一點編程經驗，但從來沒有接觸過PlayJava，然而一周入門，一個月獨立完成項目。但是PlayScala沒那么簡單，雖然后者的開發效率更高，但是由于Scala程序員匱乏，PlayScala只適合團隊較小(10人以下)并且較穩定的情況下使用。其實有很多人懷疑，Scala到底能提高多少開發效率，這里有一行Scala代碼，大家可以先體會一下：

Source.fromFile("D:/f.txt", "UTF-8").getLines().toList.distinct.sortBy(s => (s.charAt(0), s.length)).foreach( println _)

雖然只有一行代碼，但是卻做了很多事情：以UTF-8編碼讀取文件所有行 -> 去重 -> 按首字符排序，首字符相同按長度排序 -> 打印結果。各位腦補一下Java的實現。更多的一行代碼請查看酷炫的一行代碼 - Scala就是這么任性！。下面我們進入正題，先看Scala語言簡介。

2 Scala簡介

提到編程語言，大家的第一反應通常是面向對象編程(OOP), 然而隨著硬件服務器CPU核數和個數越來越多，函數式編程(FP)語言又重新回到了人們的視線。兩種編程語言都各有特點，面向對象編程符合人類對世界的認知，更容易理解；函數式編程的語法更接近人類語言，簡潔高效。兩種語言都讓人無法取舍。而Scala將這兩種編程語言完美的融合到一起，形成一門更加強大的JVM語言，同時Scala修正了Java很多不合理的設計，新增了更多高級特性，學習Scala的同時也是對Java的一次深度回顧，讓你對編程語言的理解更加地深刻。與Java相比，Scala的設計更加一致：

• 一切都是對象

  1.toDouble  //可以直接調用基本類型上的方法"1".toInt //將字符串轉換成整型

• 一切都是方法

  "a" * 3 //等價于: "a".*(3)2 - 1   //等價于: 2.-(1)

• 一切都是表達式

  val i = if(true){ 1 } else { 0 } // i = 1

Scala擁有一套強大的類型推導系統，所以你可以像動態類型語言那樣編碼，降低代碼冗余度，減少無意義擊鍵次數同時，代碼也顯得更加清晰易懂。
另外Java和Scala對待程序員的態度也很有意思，這里只是開個玩笑，大家別太在意。Java認為他所面對的程序員是一幫小白，容易犯錯誤，所以想方設法的限制你，避免你犯錯；而Scala則認為他所面對的程序員是一幫天才，所以盡可能的向他敞開編程語言寶庫，給他更大的自由度去想象和創作。

3 基本語法規則

3.1 變量聲明

val用于定義不可變變量，var用于定義可變變量，這里的"可變"指的是引用的可變性。val定義的變量類似于Java的final變量，即變量只能賦一次值：

val msg = "hello" // 等價于：val msg: String = "hello"var i = 1         // 等價于：var   i: Int = 1 i = i + 1

變量后面的類型聲明可以省略，每行代碼末尾的分號";"也可以省略。

3.2 函數聲明

def用于定義函數:

def max(x: Int, y: Int): Int = {    if (x > y) { x } else { y }
}
val maxVal = max(1, 2) // 2

Scala是函數式語言，所以你可以像基本類型那樣把函數賦給一個變量：

val max = (x: Int, y: Int) => {    if (x > y) { x } else { y }
}
val maxVal = max(1, 2) // 2

等號"="右邊是一個匿名函數，也就是我們常說的Lambda函數，匿名函數由參數和函數體兩部分組成，中間用"=>"隔開，這里省略了max變量的類型，因為編譯器可以自動推斷出來，完整的寫法如下：

val max: (Int, Int) => Int = (x: Int, y: Int) => {    if (x > y) { x } else { y }
}

max的類型是(Int, Int) => Int，即接受兩個Int參數，產生一個Int返回值的函數類型。

3.3 class

Scala的class定義和Java很相似：

class Counter {    private var value = 0 //你必須初始化字段
    def increment() { value += 1} //方法默認public
    def current() = value }

Scala的源文件中可以定義多個類，并且默認都是public，所以外界都可以看見。class的使用也很簡單：

val myCounter = new Counter //或new Counter()myCounter.increment()println(myCounter.current)  //或myCounter.current()

Scala中如果對象方法或類的構造器沒有參數，則括號"()"可以省略。

3.4 object

Scala沒有靜態方法和靜態字段，而是提供了object對象，也就是Java中的單例對象，即全局只有一個實例。

object Accounts {    private var lastNumber = 0
    def newUniqueNumber() = { lastNumber += 1; lastNumber }
}

因為Accounts是一個單例對象，可以直接使用而無需初始化：

val uniqueNumber = Accounts.newUniqueNumber

object的另一個用法是作為類的伴生對象， 類似于Java類上的靜態方法，只不過Scala將Java類上的靜態功能全交給object實現了。object作為伴生對象時必須和類在同一個源文件中定義，并且可以相互訪問私有屬性。

3.5 apply方法

如果某個對象obj上定義了apply方法，則我們可以這樣調用：

obj(arg1, ... , argn)

是的，你猜對了，伴生對象上的apply方法立馬就派上用場了，例如List類有一個同名的伴生對象List，那么你可以這樣初始化一個列表：

val list = List("a", "b", "c")

想想下面的Java版本，是不是感覺幸福感油然而生:

List<String> list = new ArrayList<String>();list.add("a");list.add("b");list.add("c");

3.6 塊表達式

在Scala中一切都是表達式，如果表達式含有多條語句，則使用大括號"{}"括起來，形成一個塊表達式，塊表達式的最后一條語句的值作為整個塊的返回值。

val r = {
    val i = 1
    val j = 2
    i + j
} // r = 3

4 case class和模式匹配

在Scala中接觸到新概念不要害怕，了解之后你會發現它幫你解決了很多實際問題，就如我們這里要聊的case class和模式匹配。定義一個case class的代碼如下:

case class Currency(value: Double, unit: String)

當你定義了一個case class之后，編譯器會自動幫你做如下事情：

• 自動創建伴生對象

• 為該類添加toString，hashCode和euqals方法，用于模式匹配時的結構化比較

• 為該類添加copy方法，用于快速拷貝對象

好了，下面我們來看一下模式匹配的威力：

abstract class Amountcase class Dollar(value: Double) extends Amountcase class Currency(value: Double, unit: String) extends Amountval amount = Currency(100.0, "EUR")val amountStr = 
    amount match {        case Dollar(v) => "$" + v        case Currency(v, u) => "I got " + v + u        case _ => ""
    }

在Scala中，類、函數、方法和object可以像變量一樣在任何地方定義。

Scala中默認使用的類都是不可變的，所以如果你想改變value的值需要借助copy方法：

val newAmound = amount.copy(value = 1000.0)

Scala中的模式匹配還可以實現更復雜的匹配，詳見"Programming in Scala, 3nd Edition"。如果說Java中的switch是一把***，那么Scala中的模式匹配是一架當之無愧的戰頭機。

5 map和flatMap

可能有很多人就是因為這兩個方法才迷戀上Scala的。map和flatMap是兩個高階函數，所謂高階函數就是接受函數作為參數的函數。這兩個方法各自接受一個一元函數(即只有一個參數的函數，類型為：(A) => B)，利用這個一元函數，你可以對數據流中的每一個元素進行一些操作或轉換，最終得到一個全新的數據流。
map方法接受的一元函數類型為：(A) => B:

List(1, 2, 3).map((i: Int) => { i + 1 }) // List(2, 3, 4)

也可以簡寫如下兩種形式：

List(1, 2, 3).map(i => i + 1 )List(1, 2, 3).map(_ + 1 )

你可以把第2種形式中的下劃線理解成每個元素的占位符，其實這只是編譯器的語法糖，編譯后的結果和前兩種寫法相同。使用這個語法糖的前提是下劃線"_"在函數體內只能出現一次。

在上面的例子里，map方法接受的一元函數類型是：(Int) => Int，元素的類型沒有發生改變，我們可以嘗試改變元素類型：

List(1, 2, 3).map(i => i.toString * i) // List(1, 22, 333)

這次傳入的一元函數類型是: (Int) => String，將原List從List[Int]類型轉換成了List[String]類型，完成一次數據流類型轉換。

flatMap方法接受的一元函數類型為：(A) => List[B]，我們發現該一元函數返回的類型也是一個List，flatMap方法會自動將由每個元素A轉換成的小List[B]展平成一個大的List[B]，這也是flatMap中的"flat"所要表達的意思：

List(1, 2, 3).flatMap(i => List(i, i)) // List(1, 1, 2, 2, 3, 3)

這里我們只在List上演示了map和flatMap的基本用法，Scala中所有的容器類型(例如Option, Either, Future, Set, ...)都內置了這兩個方法。除了map和flatMap，Scala的容器類型上還有很多類似的方法，例如filter, find, sortBy等等，詳見"Programming in Scala, 3nd Edition"。

6 常用類介紹

6.1 String

在Scala中，String更加方便好用：

//原始字符串一對三引號`"""`括起來，可包含多行字符串，內容不需要轉義"""Welcome here.
   Type "HELP" for help!"""http://類型轉換"100.0".toDouble//判斷字符串相等直接用"=="，而不需要使用equals方法val s1 = new String("a")
s1 == "a" // true//字符串去重"aabbcc".distinct // "abc"http://取前n個字符，如果n大于字符串長度返回原字符串"abcd".take(10) // "abcd"http://字符串排序"bcad".sorted // "abcd"http://過濾特定字符"bcad".filter(_ != 'a') // "bcd"http://字符串插值, 以s開頭的字符串內部可以直接插入變量，方便字符串構造val i = 100s"i=${i}" // "i=100"

Scala中沒有受檢異常(checked exception)，所以你沒有必要聲明受檢異常，如果真的發生異常，則會在運行時拋出。

6.2 Option

Scala用Option類型表示一個值是否存在，用來避免Java的NullPointerException。它有兩個子類：Some和None。Some類型表示值存在，None類型則表示值不存在。
常用操作：

val opt: Option[String] = Some("hello")//判斷是否為Noneopt.isEmpty // false//如果為None，則返回默認值"default"，否則返回opt持有的值opt.getOrElse("default") 
//如果為None則返回"DEFAULT"，否則將字符轉為大寫opt.fold("DEFAULT"){ value => value.toUpperCase } // "HELLO"http://功能同上opt match {  case Some(v) => v.toUpperCase  case None => "DEFAULT"}

6.3 List

在Scala中，List要么是Nil(空列表)，要么就是由head和tail組成的遞歸結構。 head是首元素，tail是剩下的List。所以你可以這樣構建List：

val list = 1 :: Nil // 等價于：val list = List(1)

連續的兩個冒號"::"就像是膠水，將List的head和tail粘在一起。
常用操作：

val list = List(1, 3, 2)//獲取第1個元素list.headOption.getOrElse(0) // 1//查找list.find(_ % 2 == 0).getOrElse(0) // 2//過濾list.filter(_ % 2 == 1) // List(1, 3)//排序list.sorted // List(1, 2, 3)//最小值/最大值/求和list.min // 1list.max // 3list.sum // 6//轉化成字符串list.mkString(",") // "1, 3, 2"

Scala提供的List基本可以實現SQL查詢的所有功能，這也是Spark為什么基于Scala開發的原因。更多功能請參考官方文檔。

在Scala中默認的集合類例如List，Set，Map，Tuple等都是不可變的，所以調用其修改方法會返回一個新的實例。如果要使用可變集合，請使用scala.collection.mutable包下相應的類。不可變類型在編寫并發代碼時很有用。

6.4 Tuple

Tuple(元組)Tuple可以容納不同類型的元素，最簡單的形態是二元組，即由兩個元素構成的Tuple, 可以使用_1, _2等方法訪問其元素：

val t = ("a", 1) // 等價于：val t: Tuple2[String, Int] = ("a", 1)t._1 // "a"t._2 // 1

也可以使用模式匹配利用Tuple同時初始化一組變量：

val t = ("a", 1)
val (v1, v2) = tv1 // "a"v2 // 1

6.5 Map

Map其實是二元組的集合：

val map = Map("a" -> 1, "b" -> 2)

"->"其實是String類型上的方法，返回一個二元組：

"a" -> 1 //等價于: ("a", 1)

所以你也可以這樣構建Map:

val map = Map(("a", 1), ("b", 2))

常用操作：

val map = Map("a" -> 1, "b" -> 2)//讀取map("a") // 1//寫入或添加鍵值map("a") = 0//刪除鍵值map - "a" // Map(b -> 2)

7 控制結構

7.1 if

if語句同樣是表達式，擁有返回值：

val i = 1val r = if(i > 0){ 1 } else { 0 } // r = 1

7.2 for

Scala中for語句功能比Java要豐富很多，你可以使用for遍歷一個List：

val list = List(1, 2, 3)
for(i <- list){
    println(i)
}

你也可以使用模式匹配遍歷一個Map：

val map = Map(("a", 1), ("b", 2))for((k, v) <- map){  println(k + ": " + v)
}

如果循環體以yield開始，for語句會返回一個新的集合：

val newList1 = for(i <- List(1, 2, 3)) yield i * 2 // List(2, 4, 6)val newList2 =
    for{
       i <- List(1, 2)
       j <- List(3, 4)
    } yield i + j //List(4, 5, 5, 6)

如果有多個集合需要遍歷，則for語句后面的圓括號"()"要換成大括號"{}"。

8 Future和Promise

Future和Promise是Scala提供的最吸引人的特性之一，借助Future和Promise你可以輕松地編寫完全異步非阻塞的代碼，這在多處理器時代顯得格外重要。

8.1 Future

Future用于獲取異步任務的返回結果。Future有兩種狀態：完成(completed)和未完成(not completed)。處于完成狀態的Future可能包含兩種情況的信息，一種是異步任務執行成功了，Future中包含異步任務執行成功的返回結果；另一種是異步任務執行失敗了，Future中包含了相應的Exception信息。Future的獨特之處在于它的值只能被寫入一次，之后就會變為一個不可變值，其中包含成功或失敗信息。你可以在Future上注冊一個回調函數，以便在任務執行完成后得到通知：

import scala.concurrent.ExecutionContext.Implicits.global
val f = Future{ 1 + 2 }
f.onComplete{ t =>
  t match{    case Success(v) => println("success: " + v)    case Failure(t) => println("failed: " + t.getMessage)
  }
}//等待任務結束Await.ready(f, 10 seconds)

onComplete方法接受一個一元函數，類型為：Try[T] => U。Try類型和Option類型很像，也有兩個子類Success和Failure，前者表示任務執行成功，后者表示任務執行失敗。

第1行import語句導入了一個隱式的ExecutionContext，你可以把它理解成是一個線程池，Future類在需要時會自動使用其上的線程。在Scala中你不需要直接和線程打交道。

由于Future也是一個容器類，所以可以使用for語句取回它的值：

val f = Future{ 1 + 2 }for(v <- f) {
    println(v) // 3}

也可以使用map方法對任務結果進行轉換：

val f1 = Future{ 1 + 2 }
val f2 = f1.map(v => v % 2)for(v <- f2) {    println(v) // 1}

利用for語句可以等待多個Future的返回結果：

val f1 = Future{ 1 + 2 }val f2 = Future{ 3 + 4 }for{    v1 <- f1
    v2 <- f2} {
    println(v1 + v2) // 10}

結合yield可以返回一個新的Future：

val f1 = Future{ 1 + 2 }val f2 = Future{ 3 + 4 }val f3 =  
    for{        v1 <- f1
        v2 <- f2
    } yield {        v1 + v2
    }

8.2 Promise

有時我們需要精細地控制Future的完成時機和返回結果，也就是說我們需要一個控制Future的開關，沒錯，這個開關就是Promise。每個Promise實例都會有一個唯一的Future與之相關聯：

val p = Promise[Int]()
val f = p.futurefor(v <- f) { println(v) }//3秒鐘之后返回3Thread.sleep(3000)p.success(3)//等待任務結束Await.ready(f, 10 seconds)

9 小結

Scala在剛入門的時候確實有點難度，各種奇怪的語法、符號漫天飛，看的云里霧里。但是在你入門之后會發現，這些奇怪的地方其實是合理的，是一種有意的設計。例如允許方法名包含特殊符號，你可以寫出下面的代碼：

"a" * 3 // "aaa"val map = Map("a" -> 1, "b" -> 2)

"*"和"->"其實是字符串上的兩個方法，允許符號作為方法名使得代碼直觀易懂。由于Scala賦予程序員對代碼很高的控制力，如果濫用就會導致天書般的代碼，這需要團隊內部進行協調，控制代碼的復雜度。Scala之父Martin Odersky也曾經表示會在2016簡化Scala語言，降低初學者的門檻。到時會有更多的人加入這個社區，一起分享編程的樂趣。

10 參考

• "Programming in Scala, 3nd Edition"

• "快學Scala"

11 附錄

11.1 開發工具推薦

IntelliJ IDEA + Scala插件

11.2 轉載聲明

轉載請注明作者joymufeng