0Pricing
Scala for Backend Engineering & Functional Programming · Lección

Coincidencia de tipos y valores

Patrones de tipos

Coincidencia de tipos y valores es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

Patrones de tipo

Además de comparar valores literales, match puede ramificar según el tipo de un valor. Esto se denomina patrón de tipo.

Debe escribir case x: Type =>; la rama se ejecuta cuando el valor es de ese tipo y lo vincula a x.

Comparar por tipo

Cuando un valor tiene un tipo general como Any, puede descubrir su tipo concreto mediante un patrón de tipo.

Cada case x: T comprueba el tipo en tiempo de ejecución.

object Main {
  def describe(x: Any): String = x match {
    case i: Int    => "an Int"
    case s: String => "a String"
    case _         => "something else"
  }
  def main(args: Array[String]): Unit = {
    println(describe(5))
    println(describe("hi"))
    println(describe(3.14))
  }
}

Uso del valor vinculado

El nombre vinculado tiene el tipo coincidente, por lo que puede llamar a sus métodos de forma segura dentro de esa rama.

No es necesario hacer una conversión: el compilador conoce el tipo dentro del caso.

object Main {
  def shout(x: Any): String = x match {
    case s: String => s.toUpperCase
    case i: Int    => (i * 2).toString
    case _         => "?"
  }
  def main(args: Array[String]): Unit = {
    println(shout("hello"))
    println(shout(21))
  }
}

Tipo y valor juntos

Puede combinar patrones de valor y patrones de tipo en el mismo match. Los patrones de valor suelen ser más específicos, así que debe colocarlos primero.

object Main {
  def check(x: Any): String = x match {
    case 0       => "zero int"
    case i: Int  => s"nonzero int $i"
    case _       => "not an int"
  }
  def main(args: Array[String]): Unit = {
    println(check(0))
    println(check(7))
    println(check("x"))
  }
}

Coincidencia con Double y Boolean

Los patrones de tipo funcionan con cualquier tipo, incluidos Double, Boolean y Char.

object Main {
  def kind(x: Any): String = x match {
    case d: Double  => s"double $d"
    case b: Boolean => s"bool $b"
    case _          => "other"
  }
  def main(args: Array[String]): Unit = {
    println(kind(2.5))
    println(kind(true))
  }
}

Coincidencia de colecciones por tipo

También puede hacer coincidir tipos contenedores como List. Aquí distinguimos una lista de otros valores.

object Main {
  def info(x: Any): String = x match {
    case l: List[_] => s"a list of size ${l.size}"
    case _          => "not a list"
  }
  def main(args: Array[String]): Unit = {
    println(info(List(1, 2, 3)))
    println(info("nope"))
  }
}

Un uso habitual: gestionar Any

Los patrones de tipo son especialmente útiles cuando una función recibe Any y debe reaccionar de forma distinta según el tipo, por ejemplo, al registrar datos o serializarlos.

object Main {
  def render(x: Any): String = x match {
    case i: Int    => s"int=$i"
    case d: Double => s"dbl=$d"
    case s: String => s"str=$s"
    case _         => "unknown"
  }
  def main(args: Array[String]): Unit = {
    List(1, 2.0, "three").foreach(v => println(render(v)))
  }
}

El orden sigue siendo importante

Como en cualquier match, los patrones de tipo se comprueban de arriba abajo. Si coloca primero un tipo más general, puede ocultar uno más específico situado debajo.

Ordene siempre los casos del más específico al más general.

object Main {
  def label(x: Any): String = x match {
    case s: String => "string first"
    case _: Any    => "anything"
  }
  def main(args: Array[String]): Unit = {
    println(label("hi"))
    println(label(99))
  }
}

Advertencia sobre el borrado de tipos

En tiempo de ejecución, los parámetros de tipo genéricos se eliminan. Por eso, List[Int] y List[String] tienen el mismo aspecto. Hacer coincidir con List[Int] solo comprueba que se trata de una List.

Use List[_] para expresarlo explícitamente y evitar advertencias.

¿Por qué usar patrones de tipo?

Los patrones de tipo le permiten:

  • Restringir de forma segura un tipo general sin hacer conversiones
  • Gestionar claramente valores heterogéneos
  • Combinarse con patrones de valor y guardias

Son un paso previo a la coincidencia con case classes y ADT.

Integración

Combine patrones de valor y de tipo para clasificar entradas mixtas.

object Main {
  def classify(x: Any): String = x match {
    case 0          => "zero"
    case i: Int     => "int"
    case s: String  => "text of length " + s.length
    case _          => "other"
  }
  def main(args: Array[String]): Unit = {
    println(classify(0))
    println(classify(5))
    println(classify("hey"))
  }
}

Comprobación rápida

Compruebe sus conocimientos sobre los patrones de tipo.

Resumen

Ha aprendido a hacer coincidir tipos:

  • case x: Type hace coincidir por tipo en tiempo de ejecución y vincula x
  • El valor vinculado tiene el tipo coincidente, por lo que no necesita una conversión
  • Combine patrones de valor y de tipo, empezando por los más específicos
  • Los parámetros genéricos se eliminan, así que use List[_]

Preguntas frecuentes

¿La lección «Coincidencia de tipos y valores» es gratis?

Sí — el texto completo de «Coincidencia de tipos y valores» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

¿Qué aprenderé en «Coincidencia de tipos y valores»?

Patrones de tipos Practicas Scala for Backend Engineering & Functional Programming con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Scala for Backend Engineering & Functional Programming?

No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Coincidencia de tipos y valores»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Scala for Backend Engineering & Functional Programming?

Sí. Cada lección de Scala for Backend Engineering & Functional Programming incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Expresiones match
  2. Coincidencia de tipos y valores
  3. Guardas y binding
  4. Deconstrucción
← Volver a Scala for Backend Engineering & Functional Programming