Scala handledning

Sammanfattning av Scala handledning

Denna scala-handledning täcker alla aspekter och ämnen av scala. Du kommer att lära dig alla grunderna från grunden som Vad är scala, installationsprocessen för scala, Scala-program, Scala-funktioner, Lazy utvärdering, Typgränssnitt, klasser och objekt, Arv, Abstraktioner, Java och skalaskillnader osv.

Scala är ett skalbart språk som används för att skriva programvara för flera plattformar. Därför fick den namnet "Scala". Detta språk är avsett att lösa problemen med Java samtidigt som den är mer koncis. Ursprungligen designad av Martin Odersky, den släpptes 2003.

Varför lära sig Scala

Här är de främsta anledningarna till att lära sig Scala programmeringsspråk:

• Scala är lätt att lära sig för objektorienterade programmerare, Java utvecklare. Det håller på att bli ett av de populära språken de senaste åren.
• Scala erbjuder förstklassiga funktioner för användare
• Scala kan köras på JVM, vilket banar väg för interoperabilitet med andra språk.
• Den är designad för applikationer som är samtidiga, distribuerade och motståndskraftiga meddelandestyrda. Det är ett av de mest krävande språken under detta årtionde.
• Det är kortfattat, kraftfullt språk och kan snabbt växa i enlighet med användarnas efterfrågan.
• Den är objektorienterad och har många funktionella programmeringsfunktioner som ger utvecklarna mycket flexibilitet att koda på det sätt de vill.
• Scala erbjuder många anktyper
• Den har mindre pannplåt om du kommer ifrån Java
• Ramverken Lift och Play skrivna i Scala ligger i tillväxtkurvan.

Hur man installerar Scala

För att börja skriva Scala-program måste du ha det installerat på din dator. För att göra detta måste du besöka deras webbplats https://www.scala-lang.org/download/ för att ladda ner den senaste versionen av Scala.

Genom att följa länken leds vi till två alternativ som vi kan välja för att installera Scala på våra maskiner. För denna Scala-handledning laddar vi ner IntelliJ IDEA.

När du besöker nedladdningslänken hittar du två versioner av IntelliJ IDE.

För denna Scala-handledning laddar vi ner Community Edition, som är gratis och kommer med allt du behöver för att skriva Scala-program.

Steg 1) Välj Community Edition
På sidan klickar du på rullgardinsmenyn i Community Edition.

Det ger oss ett alternativ att ladda ner IntelliJ IDE tillsammans med JBR som innehåller en JDK-implementering(Java Development Kit) OpenJDK som Scala behöver för att kompilera och köra koden.

Steg 2) Kör installationen
När du har laddat ner IntelliJ, dubbelklicka på den för att köra installationsguiden och följ dialogrutan.

Steg 3) Välj en plats
Välj en plats för att installera IDE.

Om du av en slump inte laddade ner den med JDK, får vi fortfarande en uppmaning där vi kan kontrollera att ladda ner den genom att markera kryssrutan.

Steg 4) Klicka på nästa
Lämna de andra standardinställningarna som de är och klicka på Nästa.

Steg 5) Klicka på startikonen
När installationen är klar, kör IntelliJ IDE genom att klicka på dess startikon i startmenyn som ett vanligt program.

Du måste fortfarande gå igenom ytterligare ett steg för att lägga till Scala-plugin till IntelliJ; du gör det genom att klicka på rullgardinsmenyn på konfigureringsmenyn längst ner till höger på skärmen och välja plugin-alternativet.

På fliken Marketplace kommer en sökning efter Scala att presentera plugin som det första resultatet under språktaggen.

Steg 6) Installera plugin
Klicka på installera, vilket leder till att plugin-programmet börjar ladda ner.

Steg 7) Starta om IDE
När nedladdningen är klar kommer du att uppmanas att starta om IDE så att det installerade insticksprogrammet kan börja fungera.

Efter omstart kommer du att hamna på samma sida som tidigare när vi körde IDE, men den här gången har vi redan installerat Scala plugin.

Scala Hello World-programmet

Steg 1) Välj alternativet Skapa projekt, vilket leder oss till en sida där vi kan välja vilken typ av språk vårt projekt ska använda.

Steg 2) välj Scala genom att markera kryssrutan Scala och klicka på nästa.

Steg 3) Välj en plats för att spara vår projektfil och ge vårt projekt ett namn.

Om katalogen inte finns kommer IntelliJ att uppmana oss att be oss om tillåtelse att skapa mappen. Acceptera och klicka på Slutför. Du kommer att tas till ditt Scala-projekt, som för närvarande inte har någon Scala-kod.

Det kommer att ta lite tid att ladda några index så oroa dig inte om du inte kan göra något omedelbart medan det finns en förloppsindikator längst ner på din IDE, det betyder helt enkelt att din IDE laddar några filer som krävs för att köra Scala och hjälp med IDE-autokomplettering.

Steg 4) Därefter klickar vi på projektfliken till vänster om IDE och expanderar så att vi kan se innehållet i vårt projekt.

För tillfället är projektet tomt och innehåller bara en .idea-mapp och hello-world.iml-fil genererad av IDE. Vårt intresse är src-mappen. Src är där vi lagrar källkoden för vårt projekt. Det är där vi skapar vår första Scala-fil.

Steg 5) Högerklicka på src för att öppna en meny för att skapa en ny Scala-fil.

Vi kommer sedan att skapa ett namn för filen, i denna Scala-handledning använder vi hej och väljer sedan från en rullgardinsmeny vad som ska läggas till som innehåll i Scala-filen. Välj "Objekt"

När vi gör detta har vi en Scala-fil som har ett Singleton-objekt som vi kommer att använda för att köra vår kod.

Nu när du har en Scala-fil med ett Hello-objekt. Du kommer att skriva ditt första program genom att utöka objektet du har skapat med hjälp av nyckelordet App.

Om du utökar vårt objekt med App berätta för kompilatorn vilken kod som ska köras när den startar ditt program. Omedelbart efter att du har utökat appen visas en grön pil på vänster sida, vilket indikerar att du nu kan köra ditt program.

Inuti Hello-objektet skriver vi en funktion println() som används för att skriva ut texten inuti det till konsolen. Vi kör vår kod genom att klicka på den gröna pilen.

Genom att klicka på pilen får vi alternativet Kör, hej, när du klickar på det kommer vår kod att börja kompileras och efter några sekunder kommer vi att se resultaten av vårt program utskrivna från konsolen som är inbyggd i IntelliJ IDE.

Och där går vi, vi har framgångsrikt installerat Scala och kört vårt första program.

Vad du kan göra med Scala

• Frontend webbutveckling med ScalaJS
• Mobil utveckling, båda Android Utveckling och IOS – med Scala Native
• Bibliotek på serversidan som HTTP4S, Akka-Http, Play Framework
• Internet of things använder
• Spelutveckling
• NLP – Natural Language Processing med hjälp av en uppsättning bibliotek ScalaNLP
• Testa avancerade programmeringstekniker som funktionell programmering och i objektorienterad programmering
• Bygg mycket samtidig kommunikationsapplikation med hjälp av skådespelare ett bibliotek för JVM inspirerat av Erlang
• Använd den för maskininlärning med hjälp av bibliotek som Figaro som gör probabilistisk programmering och Apache Spark den där

Anonyma funktioner

Scala-språket har anonyma funktioner, som också kallas funktionsliteral. Att Scala är ett funktionellt språk innebär ofta att utvecklare bryter ner stora problem i många små uppgifter och skapar många funktioner för att lösa dessa problem. För att göra det enkelt att skapa funktioner innehåller Scala dessa funktioner som kan vara instansierat utan namn. Vi kan tilldela dem direkt till variabler eller definitioner 'def' som visas i nedanstående Scala-exempel:

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

Vi kan sedan använda det normala sättet vi använder funktioner genom att skicka parametrar till dem som följer.

multiplyByTwo(3)

//6

multiplyByThree(4)

//12

Dessa metoder kommer väl till pass när vi vill ha en ren och koncis kod. Vi kan använda anonyma funktioner när vi definierar metoder som inte är stora och inte kräver mycket kod i kroppen. De är väldigt enkla och behöver ingen ceremoni för att skapa.

Dessa metoder är inte begränsade till funktioner med argument och kan användas för att instansiera metoder som inte tar in några argument.

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

De flesta av dessa anonyma funktioner används i andra delar av vår kod där vi behöver skapa en snabbfunktion på plats.

En annan anledning till att dessa funktioner också kallas inline-funktioner. Att använda anonyma funktioner är ett vanligt mönster som används genomgående i samlingsbiblioteket för att utföra snabba åtgärder över en samling.

Till exempel har vi filtermetoden som tar en inline-funktion/anonym funktion för att skapa ytterligare en samling med bara element som uppfyller kriterierna vi definierar i den anonyma funktionen.

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)

Här är metoderna vi har som anonyma funktioner de som kontrollerar om värdet vi får från listan är udda och jämnt och returnerar varan.

//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

I Scala är det också möjligt att använda jokertecken där parametern för vår anonyma funktion inte är namngiven. Till exempel

var timesTwo = (_:Int)*2

timesTwo(5)
//10

I det här scenariot namnger vi inte parametern vi skickar in. Det enda vi använder ett understreck för att representera den.

Lat utvärdering

De flesta språk utvärderar sekventiellt variabler och funktionsparametrar, en efter en. I Scala har vi ett nyckelord som heter lazy, som hjälper till att hantera värden som vi inte vill ska utvärderas förrän de har refererats.

En variabel markerad som lat kommer inte att utvärderas där den är definierad, det är allmänt känd som ivrig utvärdering, den kommer bara att utvärderas när den refereras till någon senare i koden.

Detta kan vara till hjälp när utvärdering av ett värde kan vara en dyr beräkning, om det inte är så att värdet alltid behövs kan vi rädda oss själva från att köra en dyr beräkning som kan sakta ner vår programvara genom att göra vår variabel lat.

lazy val myExpensiveValue = expensiveComputation

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

Detta är inte det enda användningsfallet för lata variabler. De hjälper också till att hantera frågor om cirkulärt beroende i kod.

Om inställningarna är falska kanske vi inte behöver använda myExpensiveValue, vilket kan leda till att vi räddar oss från att göra en dyr beräkning som hjälper till att säkerställa att användarna har trevligt med vår applikation eftersom våra andra behov kan beräknas korrekt utan att överväldigande ramen.

Om inställningarna är falska kanske vi inte behöver använda myExpensiveValue, vilket kan leda till att vi räddar oss från att göra en dyr beräkning som hjälper till att säkerställa att användarna har en trevlig tid när de använder vår applikation eftersom våra andra behov kan beräknas på lämpligt sätt utan överväldigande ramen.

Latigheten hjälper också till med funktionsargument, där argumenten bara används när de refereras inuti funktionen. Detta koncept kallas Call-by-name-parametrar.

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

Många språk använder call-by-value-sättet för att utvärdera argument. Parametern som skickas genom call-by-name kommer bara att utvärderas när det behövs i funktionskroppen och kommer inte att utvärderas innan dess. När värdet väl har utvärderats lagras det och kan återanvändas senare utan att det behöver omvärderas. Ett koncept som är känt som memoization.

Skriv inferens

I Scala behöver du inte deklarera typer för varje variabel du skapar. Detta beror på att Scala-kompilatorn kan göra typinferens på typer baserat på utvärdering av den högra sidan. Detta gör att din kod kan vara mer kortfattad – det befriar oss från att skriva beskrivningar där den förväntade typen är uppenbar

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

Högre ordningsfunktion

En högre ordningsfunktion är en funktion som kan ta funktioner som argument och kan returnera en funktion som en returtyp. I Scala betraktas funktioner som förstklassiga medborgare. Genom att använda dessa funktioner på detta sätt kan vi vara mycket flexibla i vilken typ av program vi kan göra. Vi kan skapa funktioner dynamiskt och mata in funktionalitet dynamiskt till andra funktioner.

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

I ovanstående funktion skickar vi in ​​en int och en funktion som tar en int och returnerar en int. Vi kan skicka in vilken funktion som helst av den signaturen. Med signatur menar vi en funktions input och output. En signatur av Int=>Int betyder att en funktion tar en Int som indata och returnerar en Int som dess utdata.

En signatur av ()=>Int betyder att en funktion inte tar någonting som den är indata och returnerar en Int som dess utdata. Ett exempel på en sådan funktion skulle vara en som genererar en slumpmässig int för oss.

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

Ovanstående funktion har en signatur ()=>Int

Vi kan ha en funktion som har en signatur scala ()=>Enhet. Detta innebär att funktionerna inte tar in något och inte returnerar en typ. Funktionen kan vara att göra någon form av beräkning genom att ändra något till att göra något förutbestämt.

Den här typen av metoder uppmuntras dock inte, eftersom de verkar vara en svart låda som kan påverka ett system på okända sätt. De är också otestbara. Genom att ha explicita in- och utdatatyper kan vi resonera om vad vår funktion gör.

En högre ordningsfunktion kan också returnera en funktion.

Till exempel kan vi skapa en metod som skapar en kraftfunktion, dvs tar ett nummer och applicerar kraft till det.

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

Ovanstående funktion tar en int. Vår returtyp är en anonym funktion som tar en Int x, * vi använder int x som argument för potensfunktionen.

Curry

I Scala kan vi konvertera en funktion som tar två argument till en som tar ett argument i taget. När vi skickar in ett argument tillämpar vi det delvis och slutar med en funktion som tar ett argument för att slutföra funktionen. Currying gör det möjligt för oss att skapa funktioner genom att delvis lägga till några argument.

Detta kan vara användbart för att skapa funktioner dynamiskt innan vi har en komplett uppsättning argument

def multiply two numbers(n:Int)(m:Int): Unit ={
  return n * m
}

Om vi ​​behöver skapa en funktion som multiplicerar med något specifikt tal, behöver vi inte skapa en annan multiplikationsmetod.

Vi kan helt enkelt anropa .curried på vår funktion ovan och få en funktion som tar ett argument först och returnerar en delvis tillämpad funktion

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

var multiplyByFive = multiplyTwoNumbers(5) 

multiplyByFive(4)

//returns 20

Mönstermatchning

Scala har en kraftfull inbyggd mekanism för att hjälpa oss att kontrollera om en variabel matchar vissa kriterier, ungefär som vi skulle göra i en switch-sats i Java eller i en serie om/annat-påståenden. Språket har mönstermatchning som vi kan använda för att kontrollera om en variabel är av en viss typ. Mönstermatchning i Scala är kraftfull och kan användas för att destrukturera komponenterna som har en otillämplig metod för att få fält vi är intresserade av direkt från variabeln vi matchar.

Scalas mönstermatchning ger också en trevligare syntax jämfört med switch statement.

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

Vi jämför vår variabel med en uppsättning alternativ, och när variabeln vi matchar uppfyller kriterierna, utvärderas uttrycket på höger sida av fettpilen (=>) och returneras som resultatet av matchningen.

Vi använder ett understreck för att fånga upp fall som är oöverträffade i vår kod. Det speglar beteendet hos standardfallet när man hanterar switch-satser.

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 _ => //case we have a type we don't recognize do sth else
}

I koden ovan kan du ta reda på typen av myItem-variabeln och baserat på den förgrena dig till någon specifik kod.

Mönstermatchning kontrollerar om variabeln matchar

Understrecket fungerar som en platshållare som matchar alla andra villkor som inte matchas av de andra punkterna i fallbeskrivningarna ovan. Vi tar en variabel myItem och anropar matchningsmetoden.

• vi kontrollerar om myItem är sant med och gör lite logik på höger sida av den feta pilen "=>."
• vi använder understrecket för att matcha allt som inte stämmer överens med någon av de fallsatser vi har definierat i koden.

Med Case-klasser kan vi till och med gå längre och destrukturera klassen för att få fält inuti objektet.

Genom att använda det förseglade nyckelordet för att definiera våra klasser får vi fördelen av att kompilatorn kontrollerar de fall vi försöker matcha mot och varnar oss om vi glömmer att hantera en viss.

Oföränderlighet

Det är möjligt att skapa värden som inte kan ändras av andra funktioner i Scala med hjälp av nyckelordet val. Detta uppnås i Java genom att använda det sista nyckelordet. I Scala gör vi det genom att använda ett val nyckelord när vi skapar en variabel istället för att använda var, vilket är alternativet vi skulle använda för att skapa en föränderlig variabel.

En variabel som definieras med nyckelordet val är skrivskyddad, medan en som definieras med var kan läsas och ändras av andra funktioner eller godtyckligt av användaren i koden.

var changeableVariable = 8

changeableVariable =10
//the compiler doesn't complain, and the code compiles successfully

println(changeableVariable)
//10

val myNumber = 7

myNumber = 4

//if we try this the code won't compile

Att försöka tilldela ett värde till myNumber efter att vi har deklarerat det som ett val ger ett kompileringsfel eller "omtilldelning till val."

Varför använda Immutability?

Immutability hjälper oss att förhindra kod och andra programmerare från att ändra våra värden oväntat, vilket skulle leda till oväntade resultat om de är avsedda att använda värdet vi lagrar kan de istället göra en kopia av det. På så sätt förhindras buggar som kan orsakas av att flera aktörer ändrar samma variabel.

Klasser och objekt

Vi vet alla att objekt är de verkliga enheterna, och klass är en mall som definierar objekt. Klasser har både tillstånd och beteenden. Tillstånden är antingen värden eller variabler. Beteenden är metoderna i Scala.

Låt oss titta på hur du kan definiera en klass, instansiera den och använda den med Scala.

Här kallas klassen Rectangle, som har två variabler och två funktioner. Du kan också använda parametrarna l och b direkt som fält i programmet. Du har ett objekt som har en huvudmetod och har instansierat klassen med två värden.

Exempelvis:

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 rectangle with length as $length and breadth as  $breadth"
  }
object RectObject {
  def main(args: Array[String]) {
    val rect = new Rectangle(4, 5)
    println(rect.toString)
    println(rect.getArea)    
  }
}

Alla fält och metoder är som standard offentliga i Scala. Det är viktigt att använda override eftersom toString-metoden är definierad för Object i Scala.

Arv

Scala har flera typer av arv (som singel, multi-level, multipel, hierarkisk, hybrid) som har mycket gemensamt med traditionella former som finns i Java. Du kan ärva både från klasser och egenskaper. Du kan ärva medlemmarna i en klass till en annan klass med nyckelordet "extends". Detta möjliggör återanvändning.

Det är möjligt att ärva från en klass eller flera klasser. Det är också möjligt att ärva från underklasser som själva har sina superklasser, vilket skapar en hierarki av arv i processen.

I nedanstående Scala-exempel är Base-klassen Circle och den härledda klassen Sphere. En cirkel har ett värde som kallas radie, som ärvs i klassen Sphere. Metoden calcArea åsidosätts med hjälp av nyckelordet åsidosättande.

Exempelvis:

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 
    }
  }

Abstraktion

I Scala kan vi skapa abstrakta metoder och medlemsfält med hjälp av abstrakta klasser och egenskaper. Inuti abstrakta klasser och egenskaper kan vi definiera abstrakta fält utan att nödvändigtvis implementera dem.

Exempelvis:

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"
    }
}

Dessa fält implementeras av klasserna som utökar egenskapen eller den abstrakta klassen. Du kan använda egenskaper för att skapa kontrakt om vad vår applikation ska kunna göra och sedan implementera dessa metoder senare.

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

På så sätt kan vi planera hur vår applikation kommer att se ut utan att implementera de metoder som kan hjälpa oss att föreställa oss hur olika metoder kommer att se ut. Det följer ett mönster som kallas programmering till abstraktioner och inte själva implementeringen.

Klassen som inleds med nyckelordet abstrakt kan innehålla både abstrakta och icke-abstrakta metoder. Men flera arv stöds inte i abstrakt klass. Så du kan utöka högst en abstrakt klass.

Singleton objekt

En Singleton är en klass som bara instansieras en gång i ett program. Det kommer från ett populärt och användbart programmeringsmönster som kallas "singleton-mönstret". Det är användbart för att skapa instanser som är avsedda att vara långlivade och kommer att vara allmänt tillgängliga i hela ditt program vars tillstånd är integrerad i koordineringen av händelserna i ett system. Att skapa en sådan klass i Scala är enkelt eftersom Scala ger oss ett enkelt sätt att skapa singletons med hjälp av objektnyckelordet.

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

Vi kan sedan referera till detta objekt genom hela vårt program med garantin att alla delar av vårt program kommer att se samma data eftersom det bara finns en instans av det.

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

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

Konceptet med statiska medlemmar finns inte i Scala, det är anledningen till att du behöver använda singleton-objekt, som fungerar som statiska medlemmar i en klass.

Implicita klasser

Implicita klasser är den nya funktionaliteten som lagts till efter version 2.1. Det är främst för att lägga till ny funktionalitet till de slutna klasserna.

Det implicita nyckelordet bör definieras i en klass, objekt eller egenskap. Den primära konstruktorn för en implicit klass bör ha exakt ett argument i sin första parameterlista. Den kan också innehålla en ytterligare implicit parameterlista.

I nedanstående Scala-exempel läggs ny funktionalitet till för att ersätta vokaler i en sträng med *.

object StringUtil {
  implicit class StringEnhancer(str: String) {
    
    def replaceVowelWithStar: String = str.replaceAll("[aeiou]", "*")
  }
}

Du måste importera i klassen där du använder den.

import StringUtil.StringEnhancer

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

Objektorienterad programmering (OOP) kontra funktionell programmering (FP)

I OOP konstrueras program genom att gruppera data och de funktioner som fungerar på dessa data i högt sammankopplade enheter. Objekt bär sina data i de fält och metoder som verkar på dem. I denna programmeringsstil är den huvudsakliga abstraktionen data eftersom metoderna som skapas är avsedda att arbeta på data.

Funktionell programmering, å andra sidan, separerar data och de funktioner som verkar på datan. Detta gör det möjligt för utvecklare att behandla funktioner som abstraktionen och drivkraften vid modellering av program.

Scala möjliggör funktionell programmering genom att ha funktioner som förstklassiga medborgare, vilket gör att de kan överföras som värden till andra funktioner och även returneras som värden. Kombinationen av dessa två paradigm har gjort Scala till ett utmärkt val för att bygga komplex mjukvara i olika branscher, såsom Data Science.

Viktiga ramverk på Scala

Här är några viktiga ramverk för Scala

• Spela är ett ramverk för webbapplikationer med öppen källkod som använder MVC-arkitektur. Släppt 2007 och nu licensierad under Apache, Det blev det mest populära ramverket på GitHub 2013. Företag som LinkedIn, Walmart, Samsung, Eero använder detta ramverk.
• Hiss är ett annat gratis webbramverk skrivet i Scala som lanserades 2007. Foursquare använder Lift-ramverket. Det är högpresterande, snabbare att bygga ramverk.
• Som
• Katter - Leecork
• Spark

Samtidighetsstöd

• Värdena i Scala är som standard oföränderliga. Detta gör den mycket anpassningsbar till den samtidiga miljön.
• Det finns många funktioner i Scala som gör den bäst för samtidiga applikationer.
• Futures and Promises gör det lättare att bearbeta data asynkront, vilket stödjer parallellism.
• Akka – verktygslåda som använder Actors samtidighetsmodell. Det finns ett antal skådespelare som agerar när de får meddelanden.
• Samtidighet med hjälp av trådar från Java kan även stödjas i Scala.
• Strömbehandling är en annan bra funktion som möjliggör kontinuerlig realtidsbearbetning av data.

Scala har några av de bästa samtidighetsbiblioteken i Java ekosystem.

• Native Java trådar
• Fibrer från bibliotek som Vertex
• ZIO – ett bibliotek som har primitiver för att hjälpa oss att hantera samtidighet och asynkron beräkning
• STM – Transaktion
• Framtid – inbyggd i Scala-språket

Java mot Scala

Här är de viktigaste Skillnaden mellan Java och Scala.

Skala	Java
Mer kompakt och koncis	Jämförelsevis större kodbitar
Designad och utvecklad för att vara både objekt- och funktionsorienterat språk. Stöder ett brett utbud av funktionella programmeringsfunktioner som samtidighet, oföränderlighet.	Ursprungligen utvecklat som ett objektorienterat språk och började stödja funktionella programmeringsfunktioner under de senaste dagarna. Fortfarande är inte starkt som ett funktionellt programmeringsspråk.
Använder aktörsmodell för att stödja samtidighet som är modernt	Använder den konventionella trådbaserade modellen för samtidighet.
Stöder ramverk – Lek, Lyft	Stöder fjäder, graler, mycket mer
Stöder lat utvärdering	Stöder inte lat utvärdering
Inga statiska medlemmar	Innehåller statiska medlemmar
Stöder operatörens överbelastning	Stöder inte överbelastning av operatören
Sammanställningen av källkoden går relativt långsamt	Sammanställning av källkod är snabbare än Scala
Egenskaper – agera som Java 8 gränssnitt	Java 8 gränssnitt försöker överbrygga klyftan mellan klasser och gränssnitt
Omskrivning behövs	Omskrivning krävs inte
Ingen garanti om de buggfria koderna	Fullständig försäkran om mindre defekter
Stöder bakåtkompatibilitet.	Scala stöder inte bakåtkompatibilitet.
Operators behandlas olika i Java och är inte metodanrop.	Alla operatörer på poster sker via en metod som kallas i Scala.
Stöder flera arv med klasser men inte av abstrakta klasser	Stöder inte flera arv med klasser, utan genom gränssnitt
Koden är skriven i en kompakt form.	Koden är skriven i lång form.
Scala innehåller inte det statiska nyckelordet.	Java innehåller det statiska nyckelordet.

Sammanfattning

I den här handledningen har du lärt dig hur du kommer igång med Scala. Du har också lärt dig de funktionella och objektorienterade funktionerna. Du har också upptäckt likheterna och skillnaderna mellan Java och Scala. Denna handledning borde ha hjälpt dig med en mängd olika exempel som är väl demonstrerade.