Výukový program Scala

Co je Scala?

Scala je staticky typovaný programovací jazyk, který kombinuje objektově orientované a funkcionální programování pro zlepšení škálovatelnosti aplikací. Scala běží primárně na platformě JVM a vývojáři ji mohou také použít k psaní softwaru pro nativní platformy prostřednictvím Scala-Native nebo pro prohlížeče prostřednictvím ScalaJs a... JavaScénář runtime.

Scala je škálovatelný jazyk používaný k vývoji softwaru pro více platforem, což je přesně důvod, proč dostal své jméno. Jazyk byl navržen tak, aby řešil několik problémů s výřečností, které se vyskytují v... Java a zároveň zůstal stručný. Martin Odersky navrhl Scalu a první veřejná verze se objevila v roce 2004.

Proč se učit Scala

Zde jsou hlavní důvody pro učení se programovacího jazyka Scala:

• Scala se snadno učí i pro objektově orientované programátory. Java vývojáři a v posledních letech se stal jedním z populárních jazyků.
• Scala nabízí uživatelům prvotřídní funkce.
• Scala může být spuštěna na JVM, což připravuje cestu pro interoperabilitu s jinými jazyky.
• Je navržen pro aplikace, které jsou souběžné, distribuované a odolné a založené na zprávách, což z něj činí jeden z nejžádanějších jazyků tohoto desetiletí.
• Je to stručný a výkonný jazyk, který se může rychle rozvíjet podle poptávky svých uživatelů.
• Je objektově orientovaný a obsahuje mnoho funkcí pro funkcionální programování, což vývojářům dává velkou flexibilitu v psaní kódu.
• Scala nabízí Duck Typing prostřednictvím strukturálních typů.
• Má méně šablonovitých myšlenek než Java.
• Frameworky Lift a Play, které jsou napsány ve Scale, se neustále vyvíjejí a získávají na popularitě.

Jak nainstalovat Scala

Abyste mohli začít psát programy ve Scale, musíte ji mít nainstalovanou na svém počítači. Chcete-li to provést, navštivte oficiální stránky na adrese https://www.scala-lang.org/download/ stáhnout nejnovější verzi Scaly.

Kliknutím na odkaz se vám zobrazí dvě možnosti instalace Scaly. V tomto tutoriálu o Scale použijeme IntelliJ IDEA, který poskytuje vynikající podporu Scaly ihned po vybalení z krabice.

Jakmile navštívíte odkaz ke stažení, najdete dvě edice IntelliJ IDE.

Pro tento tutoriál o Scale si stáhneme Community Edition, která je zdarma a obsahuje vše, co potřebujete k psaní programů ve Scale.

Krok 1) Vyberte komunitní verzi.
Na stránce klikněte na rozbalovací nabídku u Komunitní edice.

Nabízí možnost stažení IntelliJ IDE spolu s JBR, které obsahuje implementaci JDK (Java Vývojářská sada), jako například OpenJDK, kterou Scala potřebuje ke kompilaci a spuštění kódu.

Krok 2) Spusťte instalaci.
Po stažení IntelliJ dvakrát klikněte na instalační program a postupujte podle pokynů průvodce na obrazovce.

Krok 3) Vyberte místo.
Vyberte umístění pro instalaci IDE.

Pokud jste si nestáhli balíček s JDK, instalační program vás během instalace stále vyzve k přidání JDK pomocí zaškrtávacího políčka.

Krok 4) Klepněte na tlačítko Další.
Ostatní výchozí nastavení nechte tak, jak jsou, a klikněte na tlačítko Další.

Program Scala Hello World

Krok 5) Klikněte na ikonu spuštění.
Po dokončení instalace spusťte IntelliJ IDE kliknutím na jeho ikonu po spuštění v nabídce Start jako běžnou aplikaci.

Stále je potřeba do IntelliJ přidat plugin Scala. Klikněte na rozbalovací nabídku v konfigurační nabídce v pravém dolním rohu obrazovky a vyberte možnost Pluginy.

Na kartě Marketplace vyhledejte Scala. Plugin se zobrazí jako první výsledek pod štítkem Languages.

Krok 6) Nainstalujte plugin.
Kliknutím na tlačítko Instalovat spusťte stahování pluginu Scala.

Krok 7) Restartujte vývojové prostředí (IDE).
Po dokončení stahování budete vyzváni k restartování IDE, aby nainstalovaný plugin mohl začít fungovat.

Po restartu se vrátíte na stejnou stránku jako předtím, ale nyní je plugin Scala nainstalován a připraven.

Krok 8) Vyberte Vytvořit projekt, což vede na stránku, kde si můžete vybrat jazyk pro projekt.

Krok 9) Vyberte Scalu zaškrtnutím políčka Scala a kliknutím na tlačítko Další.

Krok 10) Vyberte umístění pro uložení souboru projektu a zadejte název projektu.

Pokud adresář neexistuje, IntelliJ požádá o povolení k vytvoření složky. Potvrďte a klikněte na Dokončit. Poté budete přesměrováni do svého projektu Scala, který aktuálně neobsahuje žádný kód Scala.

Načítání indexů nějakou dobu trvá, takže se nemusíte bát, pokud nemůžete s IDE komunikovat, zatímco se dole zobrazuje ukazatel průběhu. IDE načítá soubory potřebné ke spuštění Scaly a automatickému dokončování.

Krok 11) Klikněte na kartu Projekt vlevo od IDE a rozbalte ji, abyste viděli obsah projektu.

V tomto okamžiku je projekt prázdný a obsahuje pouze složku .idea a soubor hello-world.iml vygenerovaný IDE. Zajímavá je složka src, která obsahuje zdrojový kód projektu. Zde vytvoříte svůj první soubor Scala.

Krok 12) Klikněte pravým tlačítkem myši na src pro otevření nabídky a vytvoření nového souboru Scala.

Zvolte název souboru. V tomto tutoriálu Scala použijte ahoja poté z rozbalovací nabídky vyberte Objekt pro typ obsahu souboru Scala.

Jakmile to uděláte, budete mít soubor Scala, který obsahuje objekt singleton, který použijete ke spuštění kódu.

Nyní, když máte soubor Scala s objektem Hello, napište svůj první program rozšířením vytvořeného objektu pomocí klíčového slova App.

Rozšíření objektu o App sdělí kompilátoru, který kód má spustit při spuštění programu. Ihned po rozšíření App se na levé straně objeví zelená šipka, která značí, že program je nyní spustitelný.

Uvnitř objektu Hello napište funkci println() pro výpis textu do konzole. Program spusťte kliknutím na zelenou šipku.

Kliknutím na šipku se zobrazí možnost Spustit Hello. Jejím výběrem se kód zkompiluje a po několika sekundách se výstup programu zobrazí v konzoli IntelliJ.

Nyní jste úspěšně nainstalovali Scalu a spustili svůj první program.

Co můžete dělat se Scalou

Scala je široce používána v mnoha oblastech díky své flexibilitě a interoperabilitě JVM. Mezi běžné případy použití patří:

• Vývoj frontendového webu se ScalaJS.
• Mobilní vývoj pro Android a iOS se Scala Native.
• Serverové knihovny, jako například HTTP4S, Akka-Http a Play Framework.
• Aplikace internetu věcí (IoT).
• Vývoj hry.
• Zpracování přirozeného jazyka pomocí sady knihoven ScalaNLP.
• Společné procvičování pokročilých technik, jako je funkcionální programování a objektově orientované programování.
• Vysoce souběžné komunikační aplikace využívající actory, knihovnu pro JVM inspirovanou Erlangu.
• Strojové učení s knihovnami jako Figaro pro pravděpodobnostní programování a Apache Spark pro zpracování dat ve velkém měřítku.

Anonymní funkce

Jazyk Scala podporuje anonymní funkce, nazývané také funkční literályProtože Scala je funkcionální jazyk, vývojáři často rozdělují velké problémy na mnoho malých úkolů a vytvářejí mnoho funkcí. Aby to bylo snadné, Scala umožňuje funkce... vytvořené beze jménaMůžete je přiřadit přímo k proměnným nebo k definicím pomocí def, jak je znázorněno v následujícím příkladu Scaly:

val multiplyByTwo = (n:Int) => n * 2
def multiplyByThree = (n:Int) => n * 3

Pak je můžete použít jako běžné funkce předáním parametrů:

multiplyByTwo(3)
//6

multiplyByThree(4)
//12

Tyto metody se hodí, když chcete mít čistý a stručný kód. Anonymní funkce jsou užitečné při definování metod, které jsou malé a nevyžadují v těle mnoho kódu. Jsou velmi jednoduché a k jejich vytvoření není potřeba žádných ceremonií.

Tyto metody nejsou omezeny pouze na funkce s argumenty a lze je použít k vytvoření instancí metod, které nepřijímají žádné argumenty.

val sayHello = () => { println("hello") }

Většina těchto anonymních funkcí se používá v jiných částech kódu, kde potřebujete rychlou funkci. Z tohoto důvodu se jim také říká inline funkcePoužívání anonymních funkcí je běžný vzorec, který se objevuje v celé knihovně kolekcí k provádění rychlých akcí nad kolekcí.

Například metoda filter bere vloženou funkci pro vytvoření další kolekce pouze s prvky, které splňují kritéria definovaná v anonymní funkci.

val myList = List(1,2,3,4,5,6,7)

val myEvenList = myList.filter((n: Int) => n % 2 == 0)
//List(2,4,6)

val myOddList = myList.filter((n:Int) => n % 2 != 0)
//List(1,3,5,7)

Zde anonymní funkce kontrolují, zda je hodnota ze seznamu lichá nebo sudá, a vracejí odpovídající položku.

//the one checking that the value is even
(n: Int) => n % 2 == 0

//the one checking that the value is odd
(n:Int) => n % 2 != 0

Ve Scale je také možné použít zástupné znaky tam, kde není pojmenován parametr anonymní funkce. Například:

var timesTwo = (_:Int) * 2

timesTwo(5)
//10

V tomto scénáři parametr nepojmenováváte. K jeho reprezentaci se používá podtržítko.

Líné hodnocení

Většina jazyků postupně vyhodnocuje proměnné a parametry funkcí, jeden po druhém. V jazyce Scala klíčové slovo lazy pomáhá s hodnotami, které nechcete vyhodnocovat, dokud se na ně neodkazuje.

Proměnná označená jako lazy se nevyhodnocuje tam, kde je definována, což se běžně nazývá eager evaluation (doufejme, dychtivé vyhodnocení). Vyhodnocuje se pouze tehdy, když je na ni později v kódu odkazováno.

To může být užitečné, když by vyhodnocení hodnoty bylo nákladným výpočtem. Pokud hodnota není vždy potřeba, ušetříte si spuštění nákladného výpočtu, který může zpomalit software tím, že proměnnou uděláte línou.

lazy val myExpensiveValue = expensiveComputation

def runMethod() = {
    if(settings == true) {
        use(myExpensiveValue)
    } else {
        use(otherValue)
    }
}

Toto není jediný případ použití líných proměnných. Pomáhají také s řešením cyklických závislostí v kódu.

Pokud je příznak nastavení nastaven na hodnotu false, nemusíte používat myExpensiveValue, což vám ušetří nákladné výpočty. To pomáhá zajistit, aby uživatelé měli hladký provoz, protože se zdroje neplýtvají hodnotami, které se nikdy nečtou.

Lenost také pomáhá s argumenty funkcí, kde se argumenty používají pouze tehdy, když jsou odkázány uvnitř funkce. Tento koncept se nazývá parametry volané jménem.

def sometimesUsedString(someValue:String, defaultValue: => String) = {
 if(someValue != null) {
   use(defaultValue)
 } else {
   use(someValue)
   }
 }

Mnoho programovacích jazyků používá k vyhodnocování argumentů přístup volání podle hodnoty. Parametr předávaný metodou volání podle názvu se vyhodnocuje pouze tehdy, když je potřeba uvnitř těla funkce. Jakmile je hodnota vyhodnocena, je uložena a lze ji později znovu použít bez opětovného vyhodnocení, což je koncept známý jako memoizace.

Typ Inference

Ve Scale nemusíte deklarovat typy pro každou proměnnou, kterou vytvoříte, protože kompilátor Scaly dokáže odvodit typy z pravé strany výrazu. To umožňuje, aby byl váš kód stručnější a osvobozuje vás od psaní standardního kódu, kde je očekávaný typ zřejmý.

var first:String = "Hello, "
var second:String = "World"
var third = first + second
//the compiler infers that third is of type String

Funkce vyššího řádu

Funkce vyššího řádu je funkce, která může přijímat funkce jako argumenty a vracet funkci jako návratový typ. V jazyce Scala jsou funkce považovány za prvotřídní funkce. Použití funkcí tímto způsobem vám umožňuje být velmi flexibilní v typech programů, které můžete vytvářet. Funkce můžete vytvářet dynamicky a dynamicky předávat funkcionalitu jiným funkcím.

def doMathToInt(n:Int, myMathFunction:Int=>Int): Int = {
    myMathFunction(n)
}

Ve výše uvedené funkci předáte Int a funkci, která přijímá Int a vrací IntMůžete předat libovolnou funkci s daným podpisem. Podpisem myslíme vstup a výstup funkce. Podpis Int => Int znamená, že funkce bere jako vstup celé číslo (Int) a jako výstup vrací celé číslo (Int).

Podpis () => Int znamená, že funkce nepřijímá nic jako vstup a jako výstup vrací celé číslo. Příkladem takové funkce je funkce, která generuje náhodné celé číslo.

def generateRandomInt() = {
 return scala.util.Random.nextInt()
}

Výše uvedená funkce má podpis () => Int.

Funkce může mít také signaturu. () => UnitTo znamená, že funkce nic nepřijímá a nevrací žádný typ. Funkce může místo toho změnit nějaký stav nebo provést předem určenou akci.

Tyto druhy metod nejsou doporučovány, protože mohou fungovat jako černá skříňka, která ovlivňuje systém neznámým způsobem. Jsou také obtížnější na testování. Explicitní vstupní a výstupní typy vám umožňují uvažovat o tom, co vaše funkce dělá.

Funkce vyššího řádu může také vracet funkci. Můžete například vytvořit metodu, která vrací funkci umocňování, tedy takovou, která bere číslo a umocňuje ho.

def powerByFunction(n:Int): Int=>Int = {
  return (x:Int) => scala.math.pow(x,n).toInt
}

Výše uvedená funkce přijímá celé číslo (Int). Její návratový typ je anonymní funkce, která přijímá celé číslo (Int). x a použije ho jako argument pro mocninnou funkci.

Kari

Ve Scale můžete převést funkci, která přijímá dva argumenty, na jednu, která přijímá vždy jen jeden argument. Když předáte jeden argument, částečně ho použijete a výsledkem je funkce, která přijímá zbývající argument k dokončení volání. Currying umožňuje vytvářet funkce částečným přidáním několika argumentů.

To je užitečné pro dynamické vytváření funkcí, než máte k dispozici kompletní sadu argumentů.

def multiplyTwoNumbers(n:Int)(m:Int): Int = {
  return n * m
}

Pokud potřebujete funkci, která násobí určitým číslem, nemusíte vytvářet další metodu násobení. Na kari funkci můžete použít jeden argument a výsledek znovu použít:

def multiplyTwoNumbers(n:Int)(m:Int): Int = {
  return n * m
}

var multiplyByFive = multiplyTwoNumbers(5) _

multiplyByFive(4)

//returns 20

Shoda vzorů

Scala má výkonný vestavěný mechanismus, který vám pomůže ověřit, zda proměnná splňuje určitá kritéria, podobně jako příkaz switch v Java nebo řetězec příkazů if/else. Jazyk podporuje porovnávání vzorů, které můžete použít k ověření, zda je proměnná určitého typu. Porovnávání vzorů ve Scale je výkonné a dokáže destrukturalizovat komponenty, které mají unapply metoda pro získání polí, která vás zajímají, přímo z proměnné, která se porovnává.

Porovnávání vzorů ve Scale také nabízí příjemnější syntaxi než příkaz switch.

myItem match {
  case true => //do something
  case false => //do something else
  case  _ => //if none of the above do this by default
}

Porovnáte proměnnou se sadou možností. Pokud proměnná splňuje kritéria, vyhodnotí se výraz na pravé straně tlusté šipky (=>) a vrátí se jako výsledek shody.

Podtržítko zachycuje případy, které se v kódu neshodují, a zrcadlí tak chování výchozího případu v příkazu switch.

class Animal(var legs:Int, var sound:String)
class Furniture(var legs:Int, var color:Int, var woodType:String)

myItem match {
case myItem:Animal => //do something
case myItem:Furniture => //do something else
case _ => //unknown type, do something else
}

Ve výše uvedeném kódu můžete zjistit typ myItem proměnnou a na základě toho se rozvětvit na konkrétní kód.

Porovnávání vzorů kontroluje, zda proměnná odpovídá každému případu v daném pořadí.

Podtržítko funguje jako zástupný symbol, který odpovídá jakékoli podmínce, kterou ostatní příkazy case nesplňují. Vezmete proměnnou myItem a zavolejte match metoda.

• Zkontrolujte, zda myItem is true a spusťte logiku na pravé straně tlusté šipky „=>“.
• Použijte podtržítko pro nalezení čehokoli, co neodpovídá žádnému z příkazů case definovaných v kódu.

S třídami případů můžete třídu destrukturalizovat na extract polí uvnitř objektu.

Pomocí sealed klíčové slovo pro definování tříd, získáte výhodu, že kompilátor důkladně kontroluje případy, které se snažíte najít, a varuje vás, pokud na některý z nich zapomenete.

Nezměnitelnost

V jazyce Scala je možné vytvořit hodnoty, které nelze změnit jinými funkcemi, a to pomocí val klíčové slovo. Toho je dosaženo v Java pomocí příkazu final klíčové slovo. Ve Scale používáte val při vytváření proměnné místo var, což je alternativa pro proměnné proměnné.

Proměnná definovaná pomocí val klíčové slovo je pouze pro čtení, zatímco klíčové slovo je definováno pomocí var lze později číst a měnit jinými funkcemi nebo uživatelem v kódu.

var changeableVariable = 8

changeableVariable = 10
//the compiler does not complain, and the code compiles successfully

println(changeableVariable)
//10

val myNumber = 7

myNumber = 4

//this will not compile

Snažím se přiřadit hodnotu myNumber poté, co jej prohlásil za val vyvolá chybu při kompilaci: „znovu přiřazení k hodnotě.“

Proč používat Immutability?

Neměnnost pomáhá zabránit kódu a dalším programátorům v neočekávaných změnách hodnot, což by vedlo k nepředvídatelným výsledkům. Pokud uživatelé hodnoty potřebují ji změnit, mohou si místo toho vytvořit kopii. Tímto způsobem se zabrání chybám způsobeným změnou stejné proměnné více aktéry.

Třídy a objekty

Objekty jsou entity reálného světa a třída je šablona, ​​která definuje objekty. Třídy mají jak stav, tak chování. Stavy jsou buď hodnoty, nebo proměnné. Chování jsou ve Scale metody.

V následující části se dozvíte, jak definovat třídu, vytvořit její instanci a použít ji ve Scale.

Zde je třída s názvem Rectangle, která má dvě hodnoty a dvě funkce. Můžete také použít parametry l a b přímo jako pole v programu. Máte objekt, který má metodu main a vytváří instanci třídy se dvěma hodnotami.

Příklad:

class Rectangle(l: Int, b: Int) {
  val length: Int = l
  val breadth: Int = b
  def getArea: Int = l * b
  override def toString = s"This is a rectangle with length $length and breadth $breadth"
}
object RectObject {
  def main(args: Array[String]) {
    val rect = new Rectangle(4, 5)
    println(rect.toString)
    println(rect.getArea)
  }
}

Všechna pole a metody jsou ve Scale standardně veřejné. Je nezbytné je používat override protože toString je již definován pro každý objekt ve Scale.

Dědictví

Scala má několik typů dědičnosti (jednoduchou, víceúrovňovou, vícenásobnou, hierarchickou a hybridní), které mají mnoho společného s tradičními formami nalezenými v JavaMůžete dědit jak z tříd, tak z traitů. Členy jedné třídy dědíte do jiné třídy pomocí klíčového slova extendsTo umožňuje opakované použití.

Je možné dědit z jedné třídy nebo z více tříd. Je také možné dědit z podtříd, které samy o sobě mají své vlastní nadtřídy, čímž se vytváří hierarchie dědičnosti.

V níže uvedeném příkladu Scala je základní třída Circlea odvozená třída je SphereKružnice má hodnotu nazvanou poloměr, která je zděděna ve třídě Sphere. Metoda calcArea je přepsáno klíčovým slovem override.

Příklad:

class Circle {
  val radius = 5
  def calcArea = {
    println(radius * radius)
  }
}
class Sphere extends Circle {
 override def calcArea = {
    println(radius * radius * radius)
  }
}
  object SphereObject {
    def main(args : Array[String]) {
      new Sphere().calcArea
    }
  }

Abstracvání

Ve Scale si můžete vytvořit břišní svalytract metody a členská pole pomocí abstract třídy a vlastnosti. Vnitřní břišní svalytract třídy a vlastnosti, můžete definovat abstract polí bez jejich implementace.

Příklad:

trait MakesSound {
    var nameOfSound:String
    def sound():String
}
abstract class HasLegs(var legs:Int) {
    val creatureName:String

    def printLegs():String = {
        return s"$creatureName has this number of legs: $legs"
    }
}

Tato pole jsou implementována třídami, které rozšiřují vlastnost nebo abstractřída t. Vlastnosti můžete použít k vytvoření contracts pro to, co by aplikace měla dělat, a poté tyto metody implementovat později.

trait DatabaseService {
    def addItemName(itemName:String)
    def removeItem(itemId:Int)
    def updateItem(itemId:Int, newItemName:String)
}

Tímto způsobem můžete naplánovat, jak bude aplikace vypadat, aniž byste museli implementovat metody, např.ping si představujete, jak se budou různé metody objevovat. Řídí se vzorcem známým jako programování břišních svalůtracspíše než ke skutečné implementaci.

Třída, které uvádí abstract Klíčové slovo může obsahovat oba abstract a neabsolventnítract metody. Vícenásobná dědičnost však není v abs podporována.tract třídy, takže můžete protáhnout pouze jeden břišní svaltractřída t.

Singletonové objekty

Singleton je třída, jejíž instance se v programu vytváří pouze jednou. Pochází z populárního a užitečného programovacího vzoru známého jako „singleton pattern“. Je užitečný pro vytváření instancí, které mají být dlouhodobé a běžně přístupné v celém programu, kde stav je nedílnou součástí koordinace událostí v systému. Vytvoření takové třídy ve Scale je snadné, protože Scala poskytuje jednoduchý způsob vytváření singletonů pomocí… object klíčové slovo.

object UserProfile {
    var userName = ""
    var isLoggedIn:Boolean = false
}

Na tento objekt se pak můžete odkazovat v celém programu s garancí, že všechny části programu uvidí stejná data, protože existuje pouze jedna jeho instance.

def getLoggedInStatus():Boolean = {
   return UserProfile.isLoggedIn
}

def changeLoggedInStatus():Boolean = {
    UserProfile.isLoggedIn = !UserProfile.isLoggedIn
    return UserProfile.isLoggedIn
}

Koncept statických členů ve Scale neexistuje, a proto se používají objekty singleton, které se chovají jako statické členy třídy.

Implicitní třídy

Implicitní třídy jsou funkcí přidanou ve verzi 2.10 a používají se primárně k přidání nových funkcí do stávajících uzavřených tříd.

Jedno implicit Klíčové slovo by mělo být definováno ve třídě, objektu nebo vlastnosti. Primární konstruktor implicitní třídy musí mít v prvním seznamu parametrů právě jeden argument. Může také obsahovat další implicitní seznam parametrů.

V níže uvedeném příkladu Scala je přidána nová funkce pro nahrazení samohlásek v řetězci znakem *.

object StringUtil {
  implicit class StringEnhancer(str: String) {

    def replaceVowelWithStar: String = str.replaceAll("[aeiou]", "*")
  }
}

Implicitní třídu je potřeba importovat do třídy, kde ji používáte.

import StringUtil.StringEnhancer

object ImplicitEx extends App {
  val msg = "This is Guru99!"
  println(msg.replaceVowelWithStar)
}

Objektově orientované programování (OOP) vs. funkcionální programování (FP)

V OOP jsou programy konstruovány skupinami.ping data a funkce, které s těmito daty pracují, do vysoce propojených jednotek. Objekty nesou svá data v polích a metody s nimi pracují. V tomto stylu programování jsou hlavní abstracCílem jsou data, protože vytvořené metody jsou určeny k operacím s daty.

Funkcionální programování, na druhou stranu, odděluje data a funkce, které s nimi pracují. To umožňuje vývojářům zacházet s funkcemi jako s abstraca hnací síla při modelování programů.

Scala umožňuje funkcionální programování tím, že s funkcemi zachází jako s prvotřídními občany, což umožňuje jejich předávání jako hodnot jiným funkcím a jejich vrácení také jako hodnoty. Kombinace těchto dvou paradigmat učinila ze Scaly skvělou volbu pro tvorbu komplexního softwaru v odvětvích, jako je datová věda.

Důležité rámce na Scale

Zde jsou některé důležité frameworky pro Scalu:

• Hra je open-source webový aplikační rámec, který používá architektura MVCVydán v roce 2007 a nyní licencován pod Apache, se do roku 2013 stal jedním z nejpopulárnějších frameworků na GitHubu. Společnosti jako LinkedIn, Walmart, Samsung a Eero tento framework používají.
• Výtah je další bezplatný webový framework napsaný ve Scale, spuštěný v roce 2007. Foursquare používá framework Lift. Jedná se o vysoce výkonný framework, který se rychle vyvíjí.
• Tak jako poskytuje sadu nástrojů pro vytváření vysoce souběžných, distribuovaných a odolných aplikací řízených zprávami na JVM.
• Kočky je knihovna, která poskytuje abstracce pro funkcionální programování.
• Spark je jednotný analytický engine pro zpracování velkých dat, široce používaný v pracovních postupech pro big data a strojové učení.

Podpora souběžnosti

• Hodnoty v jazyce Scala jsou ve výchozím nastavení neměnné, což jej činí velmi přizpůsobivým souběžným prostředím.
• Scala má mnoho funkcí, díky kterým je ideální pro souběžné aplikace.
• Futures and Promises usnadňují zpracování dat asynchronně, čímž podporují paralelismus.
• Akka je sada nástrojů, která využívá model souběžnosti aktorů. Aktéři jednají, když přijímají zprávy.
• Souběžnost pomocí vláken z Java je také podporováno ve Scale.
• Zpracování streamu je další skvělou funkcí, která umožňuje kontinuální zpracování dat v reálném čase.

Scala má některé z nejlepších souběžných knihoven v Java ekosystém:

• Domácí Java vlákna.
• Vlákna z knihoven jako Vertx.
• ZIO, knihovna s primitivy pro pomoc se souběžnými a asynchronními výpočty.
• Softwarová transakční paměť (STM) pro transakce.
• Future, který je zabudován do jazyka Scala.

Java vs. Scala

Zde jsou hlavní rozdíly mezi Java a Scala.

Nejčastější dotazy