Los fundamentos y conceptos básicos de Scala son de suma importancia si planeas acercarte a este lenguaje, puesto que constituyen los comandos principales que podrás implementar en el análisis de datos. Por ello, en este post, te exponemos con gran detalle los fundamentos y conceptos básicos de Scala.
¿Qué es Scala?
Antes de entrar en materia con los fundamentos y conceptos básicos de Scala, en KeepCoding te recordamos que actualmente Scala es uno de los lenguaje de programación más usados para el manejo y desarrollo del Big Data. Esto es gracias a lo intuitivo, conciso y preciso que es como lenguaje de programación.
Fundamentos y conceptos básicos de Scala
val vs var
Estos son dos tipos de comandos que designan, por una parte, un objeto inmutable (val) y, por otra, uno mutable (var).
- Tipo de inferencia (type inference).
- val: values o valores (inmutable).
val nameWontChange = «foo»
nameWontChange = «bar» // compilation error:
reassignment to val
val namesMayChange: Array[String] = new Array(1)
namesMayChange(0) = «foo» // It’s works
val namesWontChange = Seq(«foo»)
namesWontChange(0) = «foo» // error: value update is not
a member of Seq[String]
- var: variable (mutable).
var numMayChange: Int = 3
numMayChange = 5
println(5) // 5, it’s works
- lazy vals o variable diferida (se evalúa cuando se llama).
lazy val itWillResolved = 10 // itWillResolved =
Métodos/funciones
Por otra parte, también podrás contar con estos métodos o funciones dentro de Scala:
- Tipo de inferencia (type inference).
- La última línea debe ser un return (last line as return).
def greet(name: String): Unit = println(s»Hello $name»)
def greet(name: String): String = s»Hello $name»
def sum(n: Int, m: Int): Int = n + m
- Métodos anidados (nested methods).
def factorial(i: Int): Int = {
def fact(i: Int, acc: Int): Int = {
if (i <= 1) acc
else fact(i – 1, i * acc)
}
fact(i, 1)
}
- Métodos o funciones variables (variable args number).
def greet(names: String) =
println(s»Hello ${names.mkString(«, «)}»)
def sum(n: Int): Int = n.reduce((n, m) => n+m)
- Métodos vs funciones.
def m(x: Int) = 2 * x
val f = (x: Int) => 2 * x
Class
Este comando forma parte de los fundamentos y conceptos básicos de Scala y consiste en designar la clase de determinado objeto, como se muestra a continuación en su desarrollo:
class User(val name: String, val lastName: String, var active: Boolean = false) {
val fullName: String = s»$name $lastName»
val role: String = {
if (name == «Carlos») «admin»
else «guess»
}
println(«Init block expression»)
println(s»Role is: $role»)
def greet(): Unit = println(s»Hello i’m $fullName»)
}
val user = new User(«John», «Doe»)
println(user.fullName)
user.active = true
println(user.greet())
Clase abstracta o abstract class
Hace referencia a los comandos en los que se oculta algo, de manera que se abstraen. Asimismo, debes considerar que no admite herencias múltiples. A continuación, su sintaxis:
abstract class Pet(val name: String, val age: Int) {
val greeting: String
protected val ageMultiplier: Int = 1
def greet(): Unit = {
println(greeting)
}
def getHumanAge(): Int = ageMultiplier * age
def sleep(): Unit
class Dog(name: String, age: Int) extends Pet(name, age) {
val greeting = «I’m a Dog»
override protected val ageMultiplier = 7
override def sleep(): Unit = {
println(«Sleeping»)
}
}
val dog = new Dog(«Rex», 5)
dog.greet()
dog.sleep()
println(dog.getHumanAge())
Trait
Se conoce así como parte de los fundamentos y conceptos básicos de Scala a los códigos reutilizables de Scala. Ahora, te compartimos su sintaxis:
trait Bird {
val name: String
override def toString(): String = s»My name is $name»
}
trait Flying {
def fly(): Unit = println(«Flying…»)
override def toString(): String = s»I can fly»
}
trait Swimmer {
def swim(): Unit = println(«Swimming…»)
override def toString(): String = s»I can swim»
}
Por otra parte, este comando también hace parte de los fundamentos y conceptos básicos de Scala por la siguiente sintaxis:
class Duck extends Bird with Flying with Swimmer {
override val name = «Duck»
override def toString(): String =
s»${super[Bird].toString} and
${super[Flying].toString} and
${super[Swimmer].toString}»
}
class Pigeon extends Bird with Flying {
override val name = «Pigeon»
}
class Penguin extends Bird with Swimmer {
override val name = «Penguin»
¿Cuál es el siguiente paso?
Por medio de este post, te has familiarizado con los fundamentos y conceptos básicos de Scala como parte del mundo del Big Data, y te hemos expuesto los comandos más importantes que puedes implementar a tu procesamiento de datos efectivamente. ¡Pero aún falta mucho por aprender!
Por este motivo, en KeepCoding contamos con el Bootcamp Full Stack Big Data, Inteligencia Artificial & Machine Learning. Gracias a este bootcamp, podrás instruirte en profundidad por medio de once módulos sobre los principales sistemas, lenguajes y herramientas que trabajan con el procesamiento de los macrodatos. ¡Apúntate!
