Pattern Matching en Scala es una de las librerías básicas de este lenguaje de programación. En efecto, por medio de esta serie de comandos se establecen funciones que ayudan en el procesamiento de los macrodatos como parte de este extenso mundo del procesamiento del Big Data.
Sin duda, este tipo de conocimientos sobre uno de los lenguajes de programación más utilizados se instaura como uno fundamental para un buen Data Scientist. Por ello, en este post, te explicaremos qué es Pattern Matching en Scala y cuáles son sus principales categorías.
¿Qué es Scala?
Como primera instancia, antes de exponerte qué es Pattern Matching en Scala, es imprescindible saber lo que significa el lenguaje de programación Scala dentro del mundo Big Data.
Pues bien, Scala fue creado en el año 2003 por Martin Odersky en la EPFL (Escuela Politécnica Federal de Lausana) y, como ya se ha mencionado, actualmente es uno de los lenguaje de programación más usados para el manejo y desarrollo del Big Data.
Incluso lo utilizan empresas potencia como son Twitter, Coursera, Disney, Telefónica o Netflix, entre otras.
Por último, Scala es un lenguaje de propósito general que se ejecuta en la JVM (Máquina virtual Java o Java Virtual Machine), es multiparadigma, funcional y está orientado a objetos. Por ello, no solo trabaja con Big Data, sino que también se implementa en proyectos DSL (Digital Subscriber Line o Línea de Abonado Digital).
¿Qué es Pattern Matching en Scala?
Coincidencia de Patrones o Pattern Matching en Scala es una estrategia de este popular lenguaje de programación que consiste en poner en consideración un objeto con respecto a los demás. De manera que la categoría, valor o expresión de un dato se valora al ponerse frente a las demás categorías, valores o expresiones del resto de los datos que se están procesando.
En definitiva, Pattern Matching en Scala es una de las operaciones más vigorosas, puesto que una vez se establecen los parámetros con lo que se regirá el dato, el objeto puede llegar a deconstruirse con base a estos.
Pues bien, dentro de la Coincidencia de Patrones o Pattern Matching en Scala, podrás encontrar dos series de comandos: uno básico y uno con extractores.
Basic Pattern Matching
En primer lugar, Basic Pattern Matching en Scala consta de las opciones más sencillas para identificar un patrón conforme al valor que se está trabajando. A continuación, te compartimos un breve ejemplo ilustrativo al respecto:
def defcon(level: Int): String = {
level match {
case 1 => «Nuclear war is imminent»
case 2 => «Next step to nuclear war»
case 3 => «Increase in force readiness above that required for normal readiness»
case 4 => «Increased intelligence watch and strengthened security measures»
case 5 => «Lowest state of readiness»
case _ => throw new Exception(«Invalid defcon value»)
}
def canSwim(bird: Bird): Boolean =
bird match {
case : Swimmer => true
case _ => false
}
def isFullEquip(bird: Bird): Boolean =
bird match {
case b if b.isInstanceOf[Swimmer] && b.isInstanceOf[Flying] => true
case _ => false
}
Pattern Matching Extractors
Por otra parte, Pattern Matching Extractors o Scala Extractor se refiere a la posibilidad de rastrear las coincidencias de patrones con base a un objeto extractor. A continuación, te exponemos un ejemplo de cómo se desarrolla su sintaxis:
case class User(name: String, email: String)
def isGmailUser(user: User): Boolean = user match {
case User(, email) if email.endsWith(«@gmail.com») => true
case => false
}
def parseArg(arg : String, value: Any) = (arg, value) match {
case («-l», lang: String) => setLanguageTo(lang)
case («-i», iterations: Int) => setIterationsTo(iterations)
case («-h» | «–help», _) => displayHelp()
case unk => throw new Exception(s»Unsupported argument ${unk._1}${unk._2}»)
}
sealed trait Expression
case object X extends Expression
case class Const(value: Int) extends Expression
case class Add(left: Expression, right: Expression) extends Expression
case class Mult(left: Expression, right: Expression) extends Expression
def eval(expression : Expression, xValue: Int): Int = expression match {
case X => xValue
case Const(value) => value
case Add(left, right) => eval(left, xValue) + eval(right, xValue)
case Mult(left, right) => eval(left, xValue) * eval(right, xValue)
}
val expr = Add(Const(1), Mult(Const(2), Mult(X, X)))
eval(expr, 2) // 9
case class User(name: String, email: String, active: Boolean)
user match {
case user @ User(, , true) => save(user)
case _ => _
}
¿Cómo seguir aprendiendo sobre Big Data?
En este post, has podido conocer que´ es Pattern Matching en Scala, a partir de la teoría y también desde la práctica. No obstante, este conocimiento requiere de una disciplina y desarrollo en la práctica de la consola por medio de una metodología de ensayo y error. Por este motivo, resulta necesario seguir aprendiendo al respecto.
Si aún no sabes cómo, en KeepCoding te ofrecemos el Bootcamp Full Stack Big Data, Inteligencia Artificial & Machine Learning. Por medio de este, se te presentarán las teorías del aprendizaje automático con énfasis en algoritmos de regresión y clasificación. De manera que, con el tiempo, serás capaz de conocer las ventajas y desventajas de los distintos algoritmos analizados. Además, adquirirás experiencia gracias a que se fusionan los fundamentos con ejemplos prácticos y realistas para que puedas aplicarlos. ¡Pide información, inscríbete ahora y sigue aprendiendo!
