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.
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”
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!
