Scala

Angol

Főnév

Scala (tsz. Scalas)

(informatika) A Scala (Scalable Language) egy magas szintű, általános célú programozási nyelv, amelyet Martin Odersky fejlesztett ki 2003-ban a svájci EPFL egyetemen. A Scala célja az volt, hogy egyesítse a funkcionális programozás és az objektumorientált szemlélet legjobb elemeit, miközben teljes mértékben együttműködjön a Java ökoszisztémával.

A Scala kódja lefordul Java bájtkóddá, így a JVM-en (Java Virtual Machine) fut. Ennek köszönhetően hozzáfér az összes Java könyvtárhoz és lehetővé teszi a zökkenőmentes interoperabilitást.

Fő jellemzők

Tisztán objektumorientált: minden érték objektum.
Tisztán funkcionális: függvények elsőrendű értékek, támogatja az immutabilitást, zárványokat (closure).
Statikusan típusos, de a típusinferencia leegyszerűsíti a szintaxist.
JVM-en fut, kompatibilis a Java könyvtárakkal.
Magas absztrakciós képességek: támogatja az osztályokat, objektumokat, mixin-eket (traits), generikusokat.
Könnyű párhuzamosítás: például az Akka könyvtárral (actor model).
Tiszta szintaxis: kevesebb boilerplate kód, mint Java-ban.

Hello, World! Scala nyelven

object Hello {
  def main(args: Array[String]): Unit = {
    println("Hello, World!")
  }
}

Alapvető szintaxis

Változók

val x = 10         // immutable (nem változtatható)
var y = 20         // mutable (változtatható)

A val a preferált, funkcionális kódolásban az immutabilitás kulcsfontosságú.

Típusinferencia

A Scala képes automatikusan kitalálni a típusokat:

val nev = "Dani"       // automatikusan String
val szam: Int = 42     // típus explicit is megadható

Függvények

A Scala a függvényeket elsőrendű objektumként kezeli:

def osszeg(a: Int, b: Int): Int = a + b

val szoroz = (x: Int, y: Int) => x * y  // anonim függvény

Függvények átadhatók másik függvénynek paraméterként (higher-order functions):

def alkalmaz(f: Int => Int, x: Int): Int = f(x)

println(alkalmaz(x => x * x, 5))  // 25

Vezérlési szerkezetek

if (x > 0) println("pozitív") else println("nem pozitív")

for (i <- 1 to 5) println(i)

while (x > 0) {
  println(x)
  x -= 1
}

Adatszerkezetek

Lista (List)

val lista = List(1, 2, 3)

println(lista.head)   // 1
println(lista.tail)   // List(2, 3)

Tömb (Array)

val tomb = Array(1, 2, 3)
tomb(0) = 10

Map

val m = Map("a" -> 1, "b" -> 2)
println(m("a"))    // 1

Osztályok és objektumok

Osztály

class Ember(val nev: String, var kor: Int) {
  def udvozles(): Unit = println(s"Szia, $nev!")
}

Objektum (singleton)

object Util {
  def duplaz(x: Int): Int = x * 2
}

Az object kulcsszóval definiált objektum egyetlen példány (singleton).

Companion object

Ha egy class és egy object ugyanazzal a névvel egy fájlban van, akkor azok egymás companionjai és megoszthatják a privát tagokat.

Trait – Többszörös öröklés mixin-ekkel

trait Beszel {
  def hello(): Unit = println("Helló!")
}

class Ember extends Beszel

Egy osztály több trait-et is örökölhet:

class Tanulo extends Ember with Beszel with Tanul

Pattern matching (mintafelismerés)

Erőteljes, funkcionális alternatíva az if-else szerkezetekre:

val x = 2
x match {
  case 1 => println("egy")
  case 2 => println("kettő")
  case _ => println("valami más")
}

Adatszerkezetek szétszedésére is jó:

val t = (1, "hello")
t match {
  case (1, s) => println(s"String: $s")
}

Option és nullbiztonság

Scala-ban ritkán használnak null-t, helyette Option típusokat:

val nev: Option[String] = Some("Dani")

nev match {
  case Some(n) => println(n)
  case None => println("Nincs név")
}

Ez segít nullpointer hibák elkerülésében.

Funkcionális elemek

Scala támogatja a map, filter, reduce és más műveleteket:

val szamok = List(1, 2, 3, 4)
val dupla = szamok.map(_ * 2)        // List(2, 4, 6, 8)
val parosak = szamok.filter(_ % 2 == 0)  // List(2, 4)
val osszeg = szamok.reduce(_ + _)    // 10

Párhuzamosítás – Akka actor modell

A Scala egyik fő könyvtára az Akka, amely az actor modellt valósítja meg. Az üzenetküldés alapú konkurencia biztonságosabb, mint a szálkezelés:

import akka.actor._

class HelloActor extends Actor {
  def receive = {
    case "hello" => println("Helló, Akka!")
    case _       => println("Ismeretlen üzenet")
  }
}

Scala vs. Java

Jellemző	Scala	Java
Típusinferencia	Igen	Részben (Java 10+)
Funkcionális	Igen	Nem natívan
Kevesebb kód	Igen	Verbózus
Futás	JVM	JVM
Nullbiztonság	Option, típusos	null lehetséges

Használati területek

Adatfeldolgozás: Apache Spark alapértelmezett nyelve
Mikroszolgáltatások: Play Framework, Akka HTTP
Backend rendszerek: REST API-k, üzleti logika
Tudományos számítás: funkcionális kifejezőereje miatt
Oktatás: funkcionális és OOP bevezetéshez

Előnyök és hátrányok

Előnyök

Erőteljes típusinferencia
Funkcionális és OO elemek ötvözése
Kifejező szintaxis, kevesebb kód
JVM-hez való szoros illeszkedés
Kiváló párhuzamosítási lehetőségek (Akka)

Hátrányok

Tanulási görbe meredek lehet (különösen Java-ról)
Fordítási idő hosszabb lehet
Kis közösség Java/Python-hoz képest

Záró gondolatok

A Scala ideális választás, ha szeretnél kihasználni a funkcionális programozás előnyeit, de nem akarod elhagyni a Java ökoszisztémát. Ha nagy teljesítményű adatfeldolgozással, mikroszolgáltatásokkal vagy párhuzamos rendszerekkel foglalkozol, érdemes lehet elmélyülni benne.

További információk

Scala - Szótár.net (en-hu)
Scala - Sztaki (en-hu)
Scala - Merriam–Webster
Scala - Cambridge
Scala - WordNet
Scala - Яндекс (en-ru)
Scala - Google (en-hu)
Scala - Wikidata
Scala - Wikipédia (angol)