0. Prefacio

La verificación de tipos y la conversión de tipos tienen implementaciones correspondientes en cada idioma, como Javaen instanceofy isInstanceen el lenguaje Scala, pero en comparación con otros idiomas, Scalapara simplificar el desarrollo, se produce una potente coincidencia de patrones. El principio Javaes switch-casemuy similar al del chino. Pero su capacidad de coincidencia es más fuerte, no solo puede hacer coincidir valores, tipos de coincidencia, sino también coincidencia de clases, sino también coincidencia de clases de prefijo, y Sparkse utiliza una gran cantidad de coincidencia de patrones en el código fuente, y la otra es la conversión implícita. En otro artículo El artículo explica que este artículo comienza con la verificación y conversión de tipos, e introduce Scalavarias coincidencias de patrones comunes y su uso.

1. Verificación de tipo

Para probar si un objeto pertenece a una clase determinada, puede utilizar isInstanceOfmétodos. Si la prueba tiene éxito, el asInstanceOfmétodo se puede utilizar para la conversión de tipos.

if(p.isInstanceOf[Employee]){
//s的类型转换为Employee
val s = p.asInstanceOf[Employee]
}

La conversión de tipos tiene principalmente los siguientes puntos a tener en cuenta:

Si p apunta a un Employeeobjeto de la clase y sus subclases, p.isInstanceOf[Employee]tendrá éxito.
Si p es nulo, p.isInstanceOf[Employee]devolverá falso y p.asInstanceOf[Employee]devolverá nulo.
Si p no es a Employee, p.asInstanceOf[Employee]lanzará una excepción.
Si desea probar que p apunta a un Employeeobjeto pero no a su subclase, puede usar: El if(p.getClass == classOf[Employee]) classOfmétodo está definido en el scala.Predefobjeto, por lo que se introducirá automáticamente. Sin embargo, en comparación con la verificación de tipos y la conversión, la coincidencia de patrones suele ser una mejor opción.

p match{
//将s作为Employee处理
case s: Employee => ...
//p不是Employee的情况
case _ => ....
}

2. Coincidencia de patrones

En resumen, la coincidencia de patrones en Scala admite los siguientes tipos de coincidencia: coincidencia de valores, coincidencia de tipos, elementos de conjunto, coincidencia de tuplas, coincidencia valorada o no valorada, echemos un vistazo a cómo se usan estos tipos de coincidencia desde el punto de código de vista. Primero, el patrón La estructura de sintaxis coincidente es la siguiente:

变量 match {
  case xx => 代码
}

Y Javano es necesario especificar las diferencias break, ese es breakel efecto de usar un marcador _de posición para representar un valor predeterminado, una adición matchy ifcomo el valor de retorno.

2.1 Coincidencia de valores

Coincidencia de valor, es decir Java, la coincidencia de entero, carácter o cadena en similar . Pero donde es una coincidencia protegida (puede entenderse como coincidencia condicional de forma predeterminada)

//字符匹配
def main(args: Array[String]): Unit = {
  val charStr = '6'
  charStr match {
    case '+' => println("匹配上了加号")
    case '-' => println("匹配上了减号")
    case '*' => println("匹配上了乘号")
    case '/' => println("匹配上了除号")
    //注意：不满足以上所有情况，就执行下面的代码
    case _ => println("都没有匹配上，我是默认值")
  }
}

//字符串匹配
def main(args: Array[String]): Unit = {
  val arr = Array("hadoop", "zookeeper", "spark")
  val name = arr(Random.nextInt(arr.length))
  name match {
  case "hadoop" => println("大数据分布式存储和计算框架...")
  case "zookeeper" => println("大数据分布式协调服务框架...")
  case "spark" => println("大数据分布式内存计算框架...")
  case _ => println("我不认识你...")
  }
}

//守卫式匹配
def main(args: Array[String]): Unit = {
  //守卫式
  val character = '*'
  val num = character match {
    case '+' => 1
    case '-' => 2
    case _ if character.equals('*') => 3
    case _ => 4
  }
  println(character + " " + num)
}

2.2 Coincidencia de tipos

La coincidencia de tipos es una Javaventaja relativa , Javano se puede hacer. El formato de coincidencia es el siguiente: case 变量名：类型se puede usar el nombre de la variable en su _lugar

//类型匹配
  def typeMathc (x: Any) = {
    x match {
      case _: String => println("字符串")
      case _: Int => println("整形")
      case _: Array[Int] => println("正星星数组")
      case _ => println("nothing")
    }
  }

2.3 Coincidencia de matrices, tuplas, conjuntos

A diferencia de la coincidencia de tipos, la coincidencia de tipos solo puede coincidir con todo el tipo grande, y este tipo de coincidencia puede coincidir de manera similar a un cierto tipo, pero también puede limitar algunos elementos del tipo coincidente

//数组模式匹配
  def arrayMatch(x: Array[Int]) = {
    x match {
      case Array(1,x,y) => println(x + ":" + y)
      case Array(1) => println("only 1 ....")
      case Array(1,_*) => println("1 开头的")
      case _ => println("nothing....")
    }

  }

  //list模式匹配
  def listMatch() = {
    val list = List(3, -1)
    //对List列表进行模式匹配，与Array类似，但是需要使用List特有的::操作符
    //构造List列表的两个基本单位是Nil和::，Nil表示为一个空列表
    //tail返回一个除了第一元素之外的其他元素的列表
    //分别匹配：带有指定个数元素的列表、带有指定元素的列表、以某元素开头的列表
    list match {
      case x :: y :: Nil => println(s"x: $x y: $y")
      case 0 :: Nil => println("only 0")
      case 1 :: _ => println("1 ...")
      case _ => println("something else")
    }
  }

  //元组匹配
  def tupleMatch() = {
    val tuple = (5, 3, 7)
    tuple match {
      case (1, x, y) => println(s"1, $x, $y")
      case (_, z, 5) => println(z)
      case _ => println("else")
    }
  }

Cuando no hay ningún valor de escritura en la matriz, las siguientes coincidencias son equivalentes y cualquier parámetro es igual a la coincidencia de tipo completa

case Array(_*) => println("*")
case _: Array[Int] => println("整个数组")

2.4 Coincidencia de clases de muestra

La clase de caso es una clase especial en Scala. Cuando se declara la clase de muestra, las siguientes cosas suceden automáticamente:

Los parámetros recibidos por el constructor principal generalmente no necesitan ser modificados explícitamente con var o val, Scala usará automáticamente val para modificar
El objeto complementario se define automáticamente para la clase de muestra y se proporciona el método de aplicación. El objeto correspondiente se puede construir sin la nueva palabra clave
Se generarán los métodos toString, equals, hashCode y copy, a menos que las definiciones de estos métodos se den explícitamente
Heredar las dos características de Producto y Serializable, lo que significa que la clase de muestra se puede serializar y se puede aplicar al método Producto

La clase de caso son casos múltiples, seguidos de parámetros de construcción, y el objeto de caso es singleton.

Además, los métodos y campos se pueden agregar a la clase de ejemplo de la clase de caso y se pueden usar para la coincidencia de patrones. ¿Cómo entender la coincidencia de patrones de la clase de muestra? Cuando se utiliza el enlace dinámico, puede juzgar a partir de la herencia de la clase de muestra si un objeto pertenece a un objeto de subclase, y la interfaz orientada a la clase principal puede simplificar el diseño de programación. isInstanceOfSimilar a lo que se mencionó en la primera parte , al mismo tiempo, la clase de muestra puede aceptar parámetros de entrada para las operaciones de subclase correspondientes.

class Amount
//定义样例类Dollar，继承Amount父类
case class Dollar(value: Double) extends Amount
//定义样例类Currency，继承Amount父类
case class Currency(value: Double, unit: String) extends Amount
//定义样例对象Nothing，继承Amount父类
case object Nothing extends Amount
object CaseClassDemo {
  def main(args: Array[String]): Unit = {
    judgeIdentity(Dollar(10.0))
    judgeIdentity(Currency(20.2,"100"))
    judgeIdentity(Nothing)
  }
  //自定义方法，模式匹配判断amt类型
  def judgeIdentity(amt: Amount): Unit = {
    amt match {
      case Dollar(value) => println(s"$value")
      case Currency(value, unit) => println(s"Oh noes,I got $unit")
      case _: Currency => println(s"Oh noes,I go")
      case Nothing => println("Oh,GOD!")
    }
  }
}

2.5 Coincidir con valor sin valor

Scala OptionEl tipo de opción se utiliza para indicar que un valor es opcional, con o sin valor. Option[T]Es un contenedor de valores opcionales de tipo T, valores que se pueden obtener mediante get()funciones Option. Si el valor existe, Option[T]es uno Some. Si no existe, Option[T]es el objeto None. OptionPor lo general, se usa en combinación con la coincidencia de patrones para determinar si una variable tiene un valor o no tiene valor. Veamos esta coincidencia con Mapel valor de retorno que se proporciona a continuación Option.

  val grades = Map("jacky" -> 90, "tom" -> 80, "jarry" -> 95)
  def getGrade(name: String): Unit = {
    val grade: Option[Int] = grades.get(name)
    grade match {
      case Some(grade) => println("成绩：" + grade)
      case None => println("没有此人成绩！")
    }
  }
  def main(args: Array[String]): Unit = {
    getGrade("jacky")
    getGrade("张三")
  }

3. Resumen

ScalaEn la coincidencia de patrones, se utiliza para simplificar el código, o para lograr una coincidencia incierta más poderosa determinada, pero también puede personalizar la coincidencia de patrones, el tiempo de coincidencia utilizando automáticamente applyy unapplymétodos. Wu Xie, Xiao San Ye, un pequeño novato en segundo plano, big data e inteligencia artificial. Presta atención a más archivo

Desarrollo de big data: explicación detallada de Scala de la verificación de tipos y la coincidencia de patrones