Fundamentos y conceptos básicos de Scala

Autor: | Última modificación: 3 de noviembre de 2023 | Tiempo de Lectura: 3 minutos
Temas en este post:

Algunos de nuestros reconocimientos:

Premios KeepCoding

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 1

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!

👉 Descubre más del Big Data, Inteligencia Artificial & Machine Learning Full Stack Bootcamp ¡Descarga el temario!

👉 Prueba el Bootcamp Gratis por una Semana ¡Empieza ahora mismo!

👉 Conoce nuestros otros Bootcamps en Programación y Tecnología

¡CONVOCATORIA ABIERTA!

Big Data, IA & Machine Learning

Full Stack Bootcamp

Clases en Directo | Profesores en Activo | Temario 100% actualizado