Scala for Backend Engineering & Functional Programming · Lección

Expresiones match

Ramifique según la forma

Expresiones match es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 1 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.

¿Qué es match?

match es una potente construcción de ramificación de Scala. Se le proporciona un valor y una serie de patrones case, y ejecuta la primera rama coincidente.

Considérelo una versión más potente y basada en expresiones de la instrucción switch.

Sintaxis básica

Debe escribir value match { case pattern => result }. Cada case define un patrón y el código que se ejecutará cuando coincida.

Como match es una expresión, el conjunto devuelve un valor.

object Main {
  def main(args: Array[String]): Unit = {
    val n = 2
    val word = n match {
      case 1 => "one"
      case 2 => "two"
      case 3 => "three"
    }
    println(word)
  }
}

El caso comodín

El guion bajo _ es un comodín que coincide con cualquier elemento. Utilícelo como caso predeterminado general al final.

Sin él, un valor sin coincidencia produce un MatchError en tiempo de ejecución.

object Main {
  def main(args: Array[String]): Unit = {
    val n = 9
    val word = n match {
      case 1 => "one"
      case 2 => "two"
      case _ => "many"
    }
    println(word)
  }
}

Comparar cadenas

Los patrones no se limitan a números. Puede comparar directamente literales de cadena.

object Main {
  def main(args: Array[String]): Unit = {
    val cmd = "start"
    val msg = cmd match {
      case "start" => "Starting up"
      case "stop"  => "Shutting down"
      case _       => "Unknown command"
    }
    println(msg)
  }
}

match devuelve un valor

Como cada rama produce un valor, puede asignar el resultado de match a un val o utilizarlo en línea.

Esto mantiene el código limpio y evita las variables mutables.

object Main {
  def main(args: Array[String]): Unit = {
    val light = "red"
    println(s"Action: " + (light match {
      case "red"   => "stop"
      case "green" => "go"
      case _       => "caution"
    }))
  }
}

Combinar casos

Puede comparar varios valores en un mismo caso mediante | (la barra vertical). Todos los valores indicados conducen a la misma rama.

object Main {
  def main(args: Array[String]): Unit = {
    val day = "Sat"
    val kind = day match {
      case "Sat" | "Sun" => "weekend"
      case _             => "weekday"
    }
    println(kind)
  }
}

match en una función

Un patrón habitual consiste en hacer que todo el cuerpo de la función sea una única expresión match. El resultado de la comparación se convierte en el valor de retorno.

object Main {
  def describe(n: Int): String = n match {
    case 0 => "zero"
    case 1 => "one"
    case _ => "other"
  }
  def main(args: Array[String]): Unit = {
    println(describe(0))
    println(describe(5))
  }
}

Vincular todo el valor

Puede vincular el valor comparado a un nombre en el caso comodín mediante case other =>. Después puede utilizar other en esa rama.

object Main {
  def main(args: Array[String]): Unit = {
    val n = 42
    val result = n match {
      case 0     => "nothing"
      case other => s"got $other"
    }
    println(result)
  }
}

El orden importa

Los casos se comprueban de arriba abajo y gana la primera coincidencia. Coloque los patrones más específicos antes que los generales.

Un comodín colocado demasiado pronto ocultaría los casos posteriores.

object Main {
  def main(args: Array[String]): Unit = {
    val n = 1
    val msg = n match {
      case 1 => "specific one"
      case _ => "anything else"
    }
    println(msg)
  }
}

¿Por qué utilizar match?

La coincidencia de patrones es fundamental en Scala porque:

Se lee claramente para ramificaciones múltiples
Devuelve un valor como expresión
Se adapta a tipos, estructuras de datos y condiciones
El compilador puede comprobar que cubra todos los casos

Integrarlo todo

Aquí tiene un clasificador pequeño que utiliza literales, un caso combinado y un caso predeterminado.

object Main {
  def grade(score: Int): String = score match {
    case 10 | 9 => "excellent"
    case 8 | 7  => "good"
    case _      => "keep trying"
  }
  def main(args: Array[String]): Unit = {
    println(grade(9))
    println(grade(7))
    println(grade(3))
  }
}

Comprobación rápida

Ponga a prueba su comprensión de las expresiones match.

Resumen

Ha aprendido los conceptos básicos de match:

La sintaxis es value match { case pattern => result }
_ es el comodín general
Combine valores con |
match es una expresión que devuelve un valor
Los casos se prueban de arriba abajo; gana la primera coincidencia

Preguntas frecuentes

¿La lección «Expresiones match» es gratis?

Sí — el texto completo de «Expresiones match» 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 «Expresiones match»?

Ramifique según la forma 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 1 de 4.

¿Cuánto tiempo toma la lección «Expresiones match»?

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

← Volver a Scala for Backend Engineering & Functional Programming