Scala匹配模式和其衍生知识

Scala的匹配模式

scala的匹配模式的关键字为match类似于Java中的switch关键字，包括常量匹配、类型匹配、列表、元组、样例类、Option 和样例对象等

import scala.util.control.Breaks

object Main {
  def main(args: Array[String]): Unit = {
    var name = ""
    var age = 0
    Breaks.breakable {
      while (true) {
        name = scala.io.StdIn.readLine()
        age = scala.io.StdIn.readInt()
        name match {
          case "李四" => println("你是李四")
          case "张三" => println("你是张三")
          case "王五" if (age >= 18) => println("王五成年了") // 守卫
          case "结束" => Breaks.break()
          case _ => println("查无此人") // 和default的作用一样
        }
      }
      val myType : Any = 12
      val res=myType match {
        case x:Int => println(s"${x} 是 Int 类型")
        case x:String => println(s"${x} 是 String 类型")
        case x:Double => println(s"${x} 是 Double 类型")
      }
      // 返回值为空
      // 对于Scala的数据结构可以匹配里面对应的值
      val myData=Array(1,2.0,"14",true)
      myData match {
        case Array(1,2.0,c:Int,d:Boolean) => println(s"${c} Int ${d} Boolean")
        case Array(1,2.0,c:String,d:Boolean) => println(s"${c} String ${d} Boolean")
      }

    }
  }
}

偏函数

偏函数（Partial Function）是 Scala 中一种特殊类型的函数，它只对函数参数的一部分值进行定义，而对其他值没有定义。偏函数通常使用 PartialFunction 类型表示。

偏函数是一种只对输入的一部分值定义的函数。在 Scala 中，可以使用 PartialFunction 类型来表示偏函数。这个类型有两个主要方法：isDefinedAt 和 apply。

• isDefinedAt(x: A): Boolean：用于检查给定的输入值是否在偏函数的定义域内。如果返回 true，则说明该输入值是偏函数的一部分定义。

• apply(x: A): B：对给定的输入值应用偏函数。在调用之前，通常会先使用 isDefinedAt 进行检查，以确保输入值在定义域内。

偏函数的一般格式，常搭配模式匹配一起使用

val partialFunction: PartialFunction[输入类型, 输出类型] = {
  case 模式1 => 表达式1
  case 模式2 => 表达式2
}

一般使用

import scala.util.control.Breaks

object Main {
  def main(args: Array[String]): Unit = {
    println(myAge("zhang",100))
    println(myAge("wang",10))
  }
  def myAge:PartialFunction[(String,Int),String] = {
      case (name,age) if  (age>=18)=> s"${name} ${age}岁 已经成年";
      case (name,age) if  (age<18&&age>0) => s"${name} ${age}岁 未成年";
      case (_,_) => "输入错误"
  }
}

柯里化

柯里化（Currying）是一种将接受多个参数的函数转换为一系列接受单一参数的函数的技术。

// 非柯里化函数
def add(a: Int, b: Int): Int = a + b

// 柯里化函数
def curryAdd(a: Int)(b: Int): Int = a + b

// 使用柯里化函数创建新函数
val addFive: Int => Int = curryAdd(5) // 部分应用，固定a为5

// 创建新函数 addTen，通过固定参数 a 为 10
val addTen: Int => Int = curryAdd(10)

// 使用新函数
val result1: Int = addFive(3) // 结果为 8
val result2: Int = addTen(3)  // 结果为 13