2. 程式人生 > 實用技巧 >[Scala學習筆記]15-樣例類和模式匹配

[Scala學習筆記]15-樣例類和模式匹配

阿新 • • 發佈：2020-07-28

ch 15

樣例類是Scala用來對物件進行模式匹配而並不需要大量的樣板程式碼的方式。

本章內容：

  • 樣例類和模式匹配的例子
  • Scala支援的各種模式
  • 密封類(sealed class)
  • Option型別

15.1 一個簡單的例子

實現一個操作算術表示式的類庫：

// 定義輸入資料
abstract class Expr // 省去了空定義體的{}
case class Var(name: String) extends Expr
case class Number(num: Double) extends Expr
case class Unop(operator: String, arg: Expr) extends Expr
case class BinOp(operator: String, left: Expr, right: Expr) extends Expr

樣例類

帶有case修飾符的類。

  1. 新增一個跟類同名的工廠方法。可以用Var("x")構造物件。
  2. 引數列表中的引數都隱式獲得了一個val字首，它們會被當作欄位。如v.name、op.left等。
  3. 編譯器會幫助我們實現toString、hashCode和equals方法。
  4. 編譯器還會新增一個copy方法用於製作修改過的，除了一兩個屬性不同之外其餘完全相同的該類的新例項。例如：op.copy(operator = "-")。用帶名字的引數給出想要做的修改，沒有給出的引數將使用老物件中的原值。

模式匹配

假定我們想簡化前面的算術表示式。可用的簡化規則如下：

  • UnOp("-", UnOp("-", e)) => e // -(-x) => +x
  • BinOp("+", e, Number(0)) => e // x+0 => x
  • BinOp("*", e, Number(1)) => e // x*1 => x

使用模式匹配實現simplifyTop函式：

def simplifyTop(expr: Expr): Expr = expr match {
    case UnOp("-", UnOp("-", e)) => e
    case BinOp("+", e, Number(0)) => e
    case BinOp("*", e, Number(1)) => e
    case _ => expr
}

Scala的match和Java的switch的區別：

  1. match是一個表示式（也就是說它總是能得到一個值）
  2. Scala的可選分支不會fall through到下一個case
  3. 如果沒有模式匹配上，會丟擲一個MatchError異常
expr match {
    case BinOp(op, left, right) =>
        println(expr + " is a binary operation")
    case _ => /* 什麼都不會發生 結果是 unit 值 */
}

15.2 模式的種類

通配模式

1. 用於預設、捕獲所有的可選路徑

case _ => // default case

2. 用於忽略某個物件中不關心的區域性

expr match {
    case BinOp(_, _, _) => println(expr + " is a binary operation")
    case _ => println("It's something else")
}

常量模式

僅匹配自己。任何字面量、val或單例物件都可以作為常量模式使用。例如5是常量，Nil是單例物件。

def describe(x: Any) = x match {
    case 5 => "five"
    case true => "truth"
    case "hello" => "hi!"
    case Nil => "the empty list"
    case _ => "something else"
}

describe(5)
describe(true)
describe("Hello!")

變數模式

匹配任何物件，Scala將對應的變數繫結成匹配上的物件。

expr match {
    case 0 => "zero"
    case somethingElse => "not zero: " + somethingElse
}

變數還是常量？

常量模式也可以有符號形式的名稱。

import math.{E, Pi}

E match {
    case Pi => "strange math? Pi = " + Pi
    case _ => "OK"
}

E並不匹配Pi。Scala採用了一個簡單的詞法規則來區分：一個以小寫字母打頭的簡單名稱會被當作模式變數處理；所有其它引用都是常量。

val pi = math.Pi

E match {
    case pi => "strange math? Pi = " + pi
}

這裡編譯器不允許新增一個預設的case。由於pi是變數模式，它將會匹配所有的輸入，因此不可能走到後面的case：

E match {
    case pi => "strange math? Pi = " + pi
    case _ => "OK"
}

如果需要，仍然可以用小寫名稱作為模式常量。

  1. 如果常量是某個物件的欄位，則可以在欄位名前面加上限定詞。例如this.pi或obj.pi。
  2. 可以用反引號將這個名稱包起來。
E match {
    case `pi` => "strange math? Pi = " + pi
    case _ => "OK"
}

構造方法模式

例如BinOp("+", e, Number(0))。

它由一個名稱(BinOp)和一組模式組成。假定這裡的名稱指定的是一個樣例類，這樣的一個模式將首先檢查被匹配的物件是否是以這個名稱命名的樣例類的例項，然後再檢查這個物件的構造方法引數是否匹配這些額外給出的模式。

expr match {
    case BinOp("+", e, Number(0)) => println("a deep match")
    case _ =>
}

序列模式

也可以和序列型別如List或Array匹配。

expr match {
    // 以0開始的3元素列表
    case List(0, _, _) => println("found it")
    case _ =>
}

expr match {
    // _*可以匹配序列中任意數量的元素
    case List(0, _*) => println("found it")
    case _ =>
}

元組模式

def tupleDemo(expr: Any) =
    expr match {
        case (a, b ,c) => println("matched " + a + b + c)
        case _ =>
    }

tupleDemo("a ", 3, "-tuple")
matched a 3-tuple

帶型別的模式

替代型別測試和型別轉換。

def generalSize(x: Any) = x match {
    case s: String => s.length
    case m: Map[_, _] => m.size
    case _ => -1
}

generalSize("abc")
generalSize(Map(1 -> 'a', 2 -> 'b'))
generalSize(math.Pi)

Scala的型別測試和轉換

  1. 型別測試：expr.isInstanceOf[String]
  2. 型別轉換：expr.asInstanceOf[String]
// 重寫case s: String => s.length這一表達式
if (x.isInstanceOf[String]) {
    val s = x.asInstanceOf[String]
    s.length
} else ...

型別擦除

測試某個值是否是Int到Int型別的對映。

def isIntIntMap(x: Any) = x match {
    case m: Map[Int, Int] => true
    case _ => false
} // wrong

Scala採用了擦除式的泛型，就跟Java一樣。這意味著在執行時並不會保留型別引數的資訊。這麼一來，我們在執行時就無法判斷某個給定的Map物件是用兩個Int的型別引數建立的，還是其他什麼型別引數建立的。系統能做的只是判斷某個值是某種不確定型別引數的Map。可以把isintlntMap應用到不同的Map類例項來驗證這個行為：

isIntIntMap(Map(1 -> 1))
isIntIntMap(Map("abc" -> "abc"))

對於這個擦除規則唯一的例外是陣列，因為Java和Scala都對它們做了特殊處理。陣列的元素型別是跟陣列一起儲存的，因此我們可以對它進行模式匹配。例如：

def isStringArray(x: Any) = x match {
    case a: Array[String] => "yes"
    case _ => "no"
}

val as = Array("abc")
isStringArray(as)

val ai = Array(1, 2, 3)
isStringArray(ai)

變數繫結

對模式新增變數。

expr match {
    // 若這個匹配成功了 則 e = UnOp("abs", _)
    case UnOp("abs", e @ UnOp("abs", _)) => e
    case _ =>
}

15.3 模式守衛

def simplifyAdd(e: Expr) = e match {
    case BinOp("+", x, y) if x == y => // 不能寫 BinOp("+", x, x)
        BinOp("*", x, Number(2))
    case _ => e
}

// 匹配正整數
case n: Int if 0 < n => ...

// 匹配'a'開頭的字串
case s: String if s(0) == 'a' => ...

15.4 模式重疊

模式會按照程式碼中的順序逐個被嘗試。

def simplifyAll(expr: Expr): Expr = expr match {
    case UnOp("-", UnOp("-", e)) =>
        simplifyAll(e)
    case BinOp("+", e, Number(0)) =>
        simplifyAll(e)
    case BinOp("*", e, Number(1)) =>
        simplifyAll(e)
    // 捕獲所有的 case 出現在更具體的簡化規則之後
    case UnOp(op, e) =>
        UnOp(op, simplifyAll(e))
    case BinOp(op, l, r) =>
        BinOp(op, simplifyAll(l), simplifyAll(r))
    case _ => expr
}

15.5 密封類

密封類除了在同一個檔案中定義的子類之外,不能新增新的子類。

sealed abstract class Expr

case class Var(name: String) extends Expr
case class Number(num: Double) extends Expr
case class Unop(operator: String, arg: Expr) extends Expr
case class BinOp(operator: String, left: Expr, right: Expr) extends Expr

若定義了一個漏掉了某些可能的case的模式匹配，則編譯器會發出警告：

def describe(e: Expr): String = e match {
    case Number(_) => "a number"
    case Var(_) => "a variable"
}

// use @unchecked to suppress warning
def describe(e: Expr): String = (e: @unchecked) match {
    case Number(_) => "a number"
    case Var(_) => "a variable"
}

Option型別

Option`可以有兩種形式：`Some(x)`和`None

val capitals = Map("France" -> "Paris", "Japan" -> "Tokyo")
capitals get "France"
capitals get "North Pole"

def show(x: Option[String]) = x match {
    case Some(s) => s
    case None => "?"
}

show(capitals get "France")
show(capitals get "Japan")
show(capitals get "North Pole")

15.7 到處都是模式

變數定義中的模式

例如，可以將一個元組中的每個元素賦值給不同變數。

val myTuple = (123, "abc")

val (number, string) = myTuple

處理樣例類時非常有用。如果你知道要處理的樣例類是什麼，就可以用 一個模式來析構它。

val exp = new BinOp("*", Number(5), Number(1))
val BinOp(op, l, r) = exp

作為偏函式的case序列

用{}包起來的一系列case語句可以用在任何允許出現函式字面量的地方。本質上講，case序列就是一個函式字面量。case序列可以有多個入口，多個引數列表。

val withDefault: Option[Int] => Int = {
    case Some(x) => x
    case None => 0
}

withDefault(Some(10))
withDefault(None)

通過case序列得到的是一個偏函式(partial function)。若將其應用到它不支援的值上，會產生一個執行時異常。

val second: List[Int] => Int = {
    case x :: y :: _ => y
}

second(List(5, 6, 7))
second(List())

若想檢查某個偏函式是否對某個入參有定義，必須首先告訴編譯器你要處理的是偏函式。

val second: PartialFunction[List[Int], Int] = {
    case x :: y :: _ => y
}

second.isDefinedAt(List(5, 6, 7))
second.isDefinedAt(List())

new PartialFunction[List[Int], Int] {
    def apply(xs: List[Int]) = xs match {
        case x :: y :: _ => y
    }
    
    def isDefinedAt(xs: List[Int]) = xs match {
        case x :: y :: _ => true
        case _ => false
    }
}

for表示式中的模式

for表示式可以從對映中接收key-value pairs，使其與模式匹配。例如：

for ((country, city) <- capitals)
    println("The capital of " + country + " is " + city)
The capital of France is Paris
The capital of Japan is Tokyo

可能存在某個模式不能匹配某個生成的值的情況。

val results = List(Some("apple"), None, Some("orange"))
for (Some(fruit) <- results) println(fruit)
apple
orange

可見生成的值當中那些不能匹配給定模式的值會被直接丟棄。

相關推薦

[Scala學習筆記]15-樣例類和模式匹配

ch 15 樣例類是Scala用來對物件進行模式匹配而並不需要大量的樣板程式碼的方式。

Java中的多執行緒學習筆記001：Thread類和Runnable介面

https://space.bilibili.com/95256449/channel/detail?cid=146244 Java中的多執行緒001 1、繼承Thread類，重寫run方法，建立執行緒物件，呼叫start()方法

JAVA學習筆記9，抽象類和介面及內部類

技術標籤：# java基礎學習筆記java抽象類多型 第九章 抽象類和介面及內部類 一 抽象類和抽象方法1.1 抽象類1.2 抽象方法1.3 abstract使用注意事項1.4 練習

Scala：(五) 類、物件、繼承、模式匹配和樣例類

類 一般類名首字母大寫 ，方法首字母小寫，類和方法命名建議符合駝峰命名法。

java學習筆記之反射—Class類例項化和物件的反射例項化

java學習筆記之反射—Class類例項化和物件的反射例項化 反射之中所有的核心操作都是通過Class類物件展開的，可以說Class類是反射操作的根源所在，但是這個類的例項化物件，可以採用三種方式完成。

Scala入門8之【樣例類（case class）、樣例物件（case object)】

技術標籤：Scalascala case class/object 1、case class1.1 定義1.2 樣例類方法1.3 與class 區別

Kotlin學習之介面、資料類和單例類

技術標籤：筆記kotlinandroidkotlin 介面 介面是用於實現多型程式設計的重要組成部分。我們都知道，Java是單繼承結構的語言，任何一個類最多隻能繼承一個父類，但是卻可以實現任意多個介面，Kotlin也是如此。

python學習筆記15.私有屬性和私有方法

技術標籤：python學習筆記python 1. 私有屬性和私有方法 1.1 應用場景和定義方式 1.1.1 應用場景

C++學習筆記：友元函式和友元類

技術標籤：C/C++學習筆記 C++學習筆記：友元函式和友元類 1.友元函式1.1 外部函式訪問類內成員1.2 友元函式的引入1.3 友元函式總結

go 學習筆記之有意思的變數和不安分的常量

首先希望學習 Go 語言的愛好者至少擁有其他語言的程式設計經驗,如果是完全零基礎的小白使用者,本教程可能並不適合閱讀或嘗試閱讀看看,系列筆記的目標是站在其他語言的角度學習新的語言,理解 Go 語言,進而寫出真正的

Python學習筆記之函式的引數和返回值的使用

01、函式引數和返回值的作用 函式根據 有沒有引數 以及 有沒有返回值，可以相互結合，共有四種：

Redis學習筆記----快取穿透,快取雪崩和熱點key

1.快取穿透 1.1 概念: 快取穿透是指查詢一個一定不存在的資料，由於快取是不命中時需要從資料庫查詢，查不到資料時則不寫入快取，這將導致這個不存在的資料每次請求都要到資料庫去查詢，造成快取穿透。

【Python學習筆記】關於sys.argv和C#與python的傳參

參考的youtube視訊連結 一開始覺得比起百度，Google搜尋效率更高。現在發現，原來Youtube才是解決問題最高效的辦法……感謝所有樂於分享的小夥伴們！！！

[Scala學習筆記] By-name Parameters

Scala By-name Parameters 原文：BY-NAME PARAMETERS in TOUR OF SCALA By-name parameters只有被使用時才會被求值，且每次引用時都會求值。

javaWeb學習筆記之關於重定向和請求轉發的區別

相同點 都會實現頁面跳轉 不同點 請求轉發的時候，URL路徑不會發生改變 重定向，URL路徑會發生改變

Pytorch學習筆記15----nn.Conv2d與Conv3d引數理解

1.Conv3d class torch.nn.Conv3d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

Scala學習筆記一（與Java、Jvm的關係以及程式執行流程分析）

一、Scala語言與Java、Jvm的關係分析 　　Scala語言是馬丁奧德斯基接觸Java語言後，針對Java語言的特點，將函數語言程式設計語言的特點融合到Java中，由此發明的。Scala語言和Java語言的；聯絡是十分緊密的。現在主流

Vue-eBookReader 學習筆記（閱讀器解析和渲染部分）

1、閱讀器解析和渲染 1.1 動態路由的設定 　　觀察成品可知，在位址列會出現書名、分類的資訊，而且可以在位址列更改資訊得到不同的書，這就利用了動態路由的技術。

[PyTorch 學習筆記] 6.1 weight decay 和 dropout

本章程式碼： https://github.com/zhangxiann/PyTorch_Practice/blob/master/lesson6/L2_regularization.py

【Arduino學習筆記】上拉電阻和下拉電阻

為什麼要用上拉電阻和下拉電阻？——避免輸入引腳處於“懸空”狀態