Scala tutorial

Resumé af Scala-tutorial

Denne scala-tutorial dækker alle aspekter og emner af scala. Du vil lære alt det grundlæggende fra bunden som Hvad er scala, installationsprocessen for scala, Scala-programmer, Scala-funktioner, Lazy-evaluering, Typegrænseflade, klasser og objekter, Arv, Abstraktioner, Java og skalaforskelle mv.

Scala er et skalerbart sprog, der bruges til at skrive software til flere platforme. Derfor fik den navnet "Scala". Dette sprog er beregnet til at løse problemerne med Java og samtidig være mere kortfattet. Oprindeligt designet af Martin Odersky, blev det udgivet i 2003.

Hvorfor lære Scala

Her er de vigtigste grunde til at lære Scala-programmeringssprog:

• Scala er let at lære for objektorienterede programmører, Java udviklere. Det er ved at blive et af de populære sprog i de senere år.
• Scala tilbyder førsteklasses funktioner til brugerne
• Scala kan udføres på FMV, hvilket baner vejen for interoperabilitet med andre sprog.
• Den er designet til applikationer, der er samtidige, distribuerede og modstandsdygtige besked-drevne. Det er et af de mest krævende sprog i dette årti.
• Det er kortfattet, kraftfuldt sprog og kan hurtigt vokse i overensstemmelse med brugernes efterspørgsel.
• Det er objektorienteret og har en masse funktionelle programmeringsfunktioner, der giver udviklerne en masse fleksibilitet til at kode på den måde, de ønsker.
• Scala tilbyder mange Andetyper
• Den har mindre kedelplade, hvis du kommer fra Java
• Rammerne Lift og Play skrevet i Scala er i vækstkurven.

Sådan installeres Scala

For at begynde at skrive Scala-programmer skal du have det installeret på din computer. For at gøre dette skal du besøge deres websted https://www.scala-lang.org/download/ for at downloade den seneste version af Scala.

Ved at følge linket ledes vi til to muligheder, som vi kan vælge for at installere Scala på vores maskiner. Til denne Scala-tutorial downloader vi IntelliJ IDEA.

Når du besøger downloadlinket, finder du to versioner af IntelliJ IDE.

Til denne Scala-tutorial downloader vi Community Edition, som er gratis og kommer med alt hvad du behøver for at skrive Scala-programmer.

Trin 1) Vælg Community Edition
På siden skal du klikke på rullemenuen på Community Edition.

Det giver os mulighed for at downloade IntelliJ IDE sammen med JBR, som indeholder en JDK implementering(Java Development Kit) OpenJDK, som Scala skal bruge for at kompilere og køre koden.

Trin 2) Kør installationen
Når du har downloadet IntelliJ, skal du dobbeltklikke på det for at køre installationsguiden og følge dialogboksen.

Trin 3) Vælg en placering
Vælg en placering for at installere IDE.

Hvis du tilfældigvis ikke downloadede den med JDK, får vi stadig en prompt, hvor vi kan tjekke for at downloade den ved at markere afkrydsningsfeltet.

Trin 4) Klik på næste
Lad de andre standardindstillinger være som de er, og klik på Næste.

Trin 5) Klik på startikonet
Når installationen er fuldført, skal du køre IntelliJ IDE ved at klikke på dets startikon i startmenuen som et almindeligt program.

Du skal stadig gennemgå et ekstra trin med at tilføje Scala-plugin'et til IntelliJ; det gør du ved at klikke på rullemenuen i konfigurationsmenuen nederst til højre på skærmen og vælge plugin-indstillingen.

På fanen Markedsplads vil en søgning efter Scala præsentere pluginnet som det første resultat under Sprog-tagget.

Trin 6) Installer plugin
Klik på installer, hvilket vil føre pluginnet i gang med at downloade.

Trin 7) Genstart IDE
Når overførslen er fuldført, bliver du bedt om at genstarte IDE, så det installerede plugin kan begynde at virke.

Efter genstart vil du finde dig selv på samme side som før, da vi kørte IDE, men denne gang har vi allerede installeret Scala-plugin'et.

Scala Hello World-programmet

Trin 1) Vælg indstillingen Opret projekt, som fører os til en side, hvor vi kan vælge, hvilken slags sprog vores projekt skal bruge.

Trin 2) vælg Scala ved at markere afkrydsningsfeltet Scala og klik på Næste.

Trin 3) Vælg en placering for at gemme vores projektfil og giv vores projekt et navn.

Hvis mappen ikke eksisterer, vil IntelliJ bede os om at bede os om tilladelse til at oprette mappen. Accepter og klik på Afslut. Du vil blive ført til dit Scala-projekt, som i øjeblikket ikke har nogen Scala-kode.

Det vil tage noget tid at indlæse nogle indekser, så bare rolig, hvis du ikke er i stand til at gøre noget med det samme, mens der er en statuslinje i bunden af ​​din IDE, det betyder simpelthen, at din IDE indlæser nogle filer, der er nødvendige for at køre Scala og hjælp til IDE-autofuldførelse.

Trin 4) Dernæst klikker vi på projektfanen til venstre for IDE og udvider, så vi kan se indholdet af vores projekt.

I øjeblikket er projektet tomt og indeholder kun en .idea-mappe og hello-world.iml-fil genereret af IDE. Vores interessepunkt er src-mappen. Src er hvor vi gemmer kildekoden til vores projekt. Det er her, vi laver vores første Scala-fil.

Trin 5) Højreklik på src for at åbne en menu for at oprette en ny Scala-fil.

Vi vil derefter oprette et navn til filen, i denne Scala-tutorial bruger vi hej og vælger derefter fra en rullemenu, hvad der skal angives som indholdet af Scala-filen. Vælg "Objekt"

Når vi gør dette, har vi en Scala-fil, der har et Singleton-objekt, som vi vil bruge til at køre vores kode.

Nu hvor du har en Scala-fil med et Hello-objekt. Du skriver dit første program ved at udvide det objekt, du har oprettet ved hjælp af app-nøgleordet.

Udvidelse af vores objekt med App fortæl compileren, hvilken kode der skal køres, når den starter dit program. Umiddelbart efter at have udvidet App, dukker en grøn pil op i venstre side, der indikerer, at du nu kan køre dit program.

Inde i Hello-objektet skriver vi en funktion println(), som bruges til at udskrive teksten inde i det til konsollen. Vi kører vores kode ved at klikke på den grønne pil.

Ved at klikke på pilen får vi muligheden Kør, hej, når du klikker på den, begynder vores kode at kompilere, og efter nogle sekunder vil vi se resultaterne af vores program udskrevet fra konsollen, der er indbygget i IntelliJ IDE.

Og der går vi, vi har med succes installeret Scala og kørt vores første program.

Hvad du kan gøre med Scala

• Frontend webudvikling med ScalaJS
• Mobil udvikling, begge dele Android Udvikling og IOS – med Scala Native
• Server-side biblioteker som HTTP4S, Akka-Http, Play Framework
• Internet of things bruger
• Spiludvikling
• NLP – Natural Language Processing ved hjælp af en række biblioteker ScalaNLP
• Afprøvning af avancerede programmeringsteknikker såsom funktionel programmering og i objektorienteret programmering
• Byg en meget samtidig kommunikationsapplikation ved hjælp af skuespillere et bibliotek til JVM inspireret af Erlang
• Brug det til maskinlæring ved hjælp af biblioteker som Figaro, der laver probabilistisk programmering og Apache Spark at

Anonyme funktioner

Scala-sproget har anonyme funktioner, som også kaldes funktionsbogstaver. At Scala er et funktionelt sprog betyder ofte, at udviklere deler store problemer op i mange små opgaver og skaber mange funktioner til at løse disse problemer. For at gøre det nemt at oprette funktioner, indeholder Scala disse funktioner, der kan være instansieret uden navn. Vi kan tildele dem direkte til variabler eller definitioner 'def' som vist i nedenstående Scala-eksempel:

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

Vi kan derefter bruge den normale måde, vi bruger funktioner på, ved at overføre parametre til dem som følger.

multiplyByTwo(3)

//6

multiplyByThree(4)

//12

Disse metoder er nyttige, når vi ønsker at have en ren og kortfattet kode. Vi kan bruge anonyme funktioner, når vi definerer metoder, der ikke er store og ikke kræver meget kode i deres krop. De er meget enkle og behøver ikke en ceremoni for at skabe.

Disse metoder er ikke begrænset til funktioner med argumenter og kan bruges til at instansiere metoder, der ikke tager nogen argumenter ind.

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

De fleste af disse anonyme funktioner bruges i andre dele af vores kode, hvor vi skal oprette en hurtig funktion på plads.

En anden grund til, at disse funktioner også kaldes inline funktioner. Anvendelse af anonyme funktioner er et almindeligt mønster, som er gennemgående brugt i samlingsbiblioteket til at udføre hurtige handlinger over en samling.

For eksempel har vi filtermetoden, der tager en inline-funktion/anonym funktion for at oprette en anden samling med kun elementer, der opfylder de kriterier, vi definerer i den anonyme funktion.

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)

Her er de metoder, vi har som anonyme funktioner, dem, der kontrollerer, om den værdi, vi får fra listen, er ulige og lige og returnerer varen.

//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 er det også muligt at bruge jokertegn, hvor vores anonyme funktions parameter ikke er navngivet. For eksempel

var timesTwo = (_:Int)*2

timesTwo(5)
//10

I dette scenarie navngiver vi ikke den parameter, vi sender ind. Det eneste, vi bruger en understregning til at repræsentere det.

Doven evaluering

De fleste sprog evaluerer sekventielt variabler og funktionsparametre, den ene efter den anden. I Scala har vi et søgeord kaldet doven, som hjælper med at håndtere værdier, som vi ikke ønsker skal evalueres, før de er blevet refereret.

En variabel, der er markeret som doven, vil ikke blive evalueret, hvor den er defineret, det er almindeligvis kendt som ivrig evaluering, den vil kun blive evalueret, når der henvises til den senere i koden.

Dette kan være nyttigt, når evaluering af en værdi kan være en dyr beregning, hvis det ikke er tilfældet, at værdien altid er nødvendig, kan vi spare os selv for at køre en dyr beregning, som kan bremse vores software ved at gøre vores variabel doven.

lazy val myExpensiveValue = expensiveComputation

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

Dette er ikke den eneste use case for dovne variabler. De hjælper også med at håndtere problemer med cirkulær afhængighed i kode.

I tilfælde af at indstillingerne er falske, behøver vi muligvis ikke bruge myExpensiveValue, hvilket kan få os til at redde os fra at lave en dyr beregning, som hjælper med at sikre, at brugerne har det godt med at bruge vores applikation, da vores andre behov kan beregnes korrekt uden at overvælde RAM.

I tilfælde af at indstillingerne er falske, behøver vi måske ikke bruge myExpensiveValue, hvilket kan få os til at spare os fra at lave en dyr beregning, som hjælper med at sikre, at brugerne har det godt med at bruge vores applikation, da vores andre behov kan beregnes korrekt uden at overvælde RAM.

Dovenskaben hjælper også med funktionsargumenter, hvor argumenterne kun bruges, når der refereres til dem inde i funktionen. Dette koncept kaldes Call-by-name parametre.

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

Mange sprog bruger call-by-value måden at evaluere argumenter på. Parameteren, der sendes gennem call-by-name, vil kun blive evalueret, når det er nødvendigt i funktionskroppen og vil ikke blive evalueret før det. Når værdien er evalueret, gemmes den og kan genbruges senere, uden at den skal revurderes. Et koncept, der er kendt som memoization.

Skriv inferens

I Scala behøver du ikke at erklære typer for hver variabel, du opretter. Dette skyldes, at Scala-kompileren kan lave typeslutning om typer baseret på evaluering af højre side. Dette gør det muligt for din kode at være mere kortfattet - det frigør os fra at skrive boilerplate, hvor den forventede type er indlysende

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

Højere-ordens-funktion

En højere-ordens funktion er en funktion, der kan tage funktioner som argumenter og kan returnere en funktion som en returtype. I Scala betragtes funktioner som førsteklasses borgere. Ved at bruge disse funktioner på denne måde kan vi være meget fleksible i den slags programmer, vi kan lave. Vi kan skabe funktioner dynamisk og tilføre funktionalitet dynamisk til andre funktioner.

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

I ovenstående funktion sender vi en int og en funktion, der tager en int og returnerer en int. Vi kan sende enhver funktion af denne signatur. Med signatur mener vi en funktions input og output. En signatur af Int=>Int betyder, at en funktion tager en Int som input og returnerer en Int som sit output.

En signatur på ()=>Int betyder, at en funktion ikke tager noget som dens input og returnerer en Int som sit output. Et eksempel på en sådan funktion ville være en, der genererer en tilfældig int for os.

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

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

Vi kan have en funktion, der har en signatur scala ()=>Enhed. Det betyder, at funktionerne ikke tager noget ind og ikke returnerer en type. Funktionen kunne være at lave en form for beregning ved at ændre noget til at gøre noget forudbestemt.

Den slags metoder tilskyndes dog ikke, da de ser ud til at være en sort boks, der kan påvirke et system på nogle ukendte måder. De er også uprøvelige. At have eksplicitte input- og outputtyper gør det muligt for os at ræsonnere om, hvad vores funktion gør.

En højere ordens funktion kan også returnere en funktion.

For eksempel kunne vi lave en metode, der vil skabe en kraftfunktion, dvs. tager et tal og anvender magt til det.

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

Ovenstående funktion tager en int. Vores returtype er en anonym funktion, der tager en Int x, * vi bruger int x som argument for potensfunktionen.

Currying

I Scala kan vi konvertere en funktion, der tager to argumenter, til en, der tager et argument ad gangen. Når vi sender et argument ind, anvender vi det delvist og ender med en funktion, der kræver et argument for at fuldføre funktionen. Currying gør det muligt for os at oprette funktioner ved delvist at tilføje nogle argumenter.

Dette kan være nyttigt til at skabe funktioner dynamisk, før vi har et komplet sæt af argumenter

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

Hvis vi skal lave en funktion, der ganges med et bestemt tal, behøver vi ikke oprette en anden multiplikationsmetode.

Vi kan blot kalde .curried på vores funktion ovenfor og få en funktion, der tager et argument først og returnere en delvist anvendt funktion

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

var multiplyByFive = multiplyTwoNumbers(5) 

multiplyByFive(4)

//returns 20

Mønstertilpasning

Scala har en kraftig indbygget mekanisme til at hjælpe os med at kontrollere, om en variabel matcher op til bestemte kriterier, ligesom vi ville gøre i en switch-sætning i Java eller i en række hvis/andet-udsagn. Sproget har mønstertilpasning, som vi kan bruge til at kontrollere, om en variabel er af en bestemt type. Mønstermatching i Scala er kraftfuld og kan bruges til at destrukturere de komponenter, der har en uanvendelig metode for at få felter, vi er interesserede i, direkte fra den variabel, vi matcher.

Scalas mønstertilpasning giver også en mere behagelig syntaks sammenlignet 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 sammenligner vores variabel med et sæt muligheder, og når den variabel, vi matcher, opfylder kriterierne, evalueres udtrykket på højre side af den fede pil (=>) og returneres som resultatet af matchningen.

Vi bruger en understregning til at fange sager, der ikke kan matche i vores kode. Det afspejler standardsagens opførsel, når man håndterer switch-sætninger.

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 ovenfor er du i stand til at finde ud af typen af ​​myItem-variablen og baseret på denne forgrening til en bestemt kode.

Mønstermatching kontrollerer, om variablen matcher

Understregningen fungerer som en pladsholder, der matcher enhver anden betingelse, der ikke matches af de andre punkter i sagsudtalelserne ovenfor. Vi tager en variabel myItem og kalder matchmetoden.

• vi tjekker, om myItem er sandt ved at bruge og laver noget logik på højre side af den fede pil "=>."
• vi bruger understregningen til at matche noget, der ikke stemmer overens med nogen af ​​de sagsudsagn, vi har defineret i koden.

Med Case-klasser kan vi endda gå længere og destrukturere klassen for at få felter inde i objektet.

Ved at bruge det forseglede søgeord til at definere vores klasser, får vi fordelen af ​​at lade compileren udtømmende tjekke de sager, vi forsøger at matche, og advare os, hvis vi glemmer at håndtere en bestemt.

uforanderlighed

Det er muligt at oprette værdier, der ikke kan ændres af andre funktioner i Scala ved hjælp af nøgleordet val. Dette opnås i Java ved at bruge det endelige søgeord. I Scala gør vi det ved at bruge et val nøgleord, når vi opretter en variabel i stedet for at bruge var, som er det alternativ, vi ville bruge til at skabe en variabel variabel.

En variabel, der er defineret ved hjælp af nøgleordet val, er skrivebeskyttet, hvorimod en, der er defineret med var, kan læses og ændres af andre funktioner eller vilkårligt af brugeren 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

At forsøge at tildele en værdi til myNumber, efter at vi har erklæret den som en val, giver en kompileringsfejl eller "omtildeling til val."

Hvorfor bruge uforanderlighed?

Uforanderlighed hjælper os med at forhindre kode og andre programmører i at ændre vores værdier uventet, hvilket ville føre til uventede resultater, hvis de er beregnet til at bruge den værdi, vi gemmer, kan de i stedet lave en kopi af den. På denne måde forhindres fejl, der kan være forårsaget af flere aktører, der ændrer den samme variabel.

Klasser og objekter

Vi ved alle, at objekter er enheder i den virkelige verden, og klasse er en skabelon, der definerer objekter. Klasser har både tilstand og adfærd. Tilstandene er enten værdier eller variable. Adfærden er metoderne i Scala.

Lad os se på, hvordan du kan definere en klasse, instansiere den og bruge den ved hjælp af Scala.

Her er klassen kaldet Rectangle, som har to variable og to funktioner. Du kan også bruge parametrene l og b direkte som felter i programmet. Du har et objekt, som har en hovedmetode og har instansieret klassen med to værdier.

Eksempel:

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

Alle felter og metode er som standard offentlige i Scala. Det er vigtigt at bruge tilsidesættelse, fordi toString-metoden er defineret for Object i Scala.

Arv

Scala har flere typer af arv (som enkelt, multi-level, multiple, hierarkisk, hybrid), der har meget til fælles med traditionelle former, der findes i Java. Du kan arve både fra klasser og karaktertræk. Du kan arve medlemmerne af en klasse til en anden klasse ved at bruge nøgleordet "forlænger". Dette muliggør genbrug.

Det er muligt at arve fra én klasse eller flere klasser. Det er også muligt at arve fra underklasser, der selv har deres superklasser, hvilket skaber et hierarki af arv i processen.

I nedenstående Scala-eksempel er Base-klassen Circle, og den afledte klasse er Sphere. En cirkel har en værdi kaldet radius, som er nedarvet i Sphere-klassen. Metoden calcArea tilsidesættes ved hjælp af nøgleordet tilsidesættelse.

Eksempel:

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 skabe abstrakte metoder og medlemsfelter ved hjælp af abstrakte klasser og træk. Inde i abstrakte klasser og træk kan vi definere abstrakte felter uden nødvendigvis at implementere dem.

Eksempel:

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

Disse felter er implementeret af de klasser, der udvider egenskaben eller den abstrakte klasse. Du kan bruge egenskaber til at oprette kontrakter om, hvad vores applikation skal kunne og derefter implementere disse metoder senere.

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

På denne måde kan vi planlægge, hvordan vores applikation vil se ud uden at implementere de metoder, som kan hjælpe os med at forestille os, hvordan forskellige metoder vil se ud. Det følger et mønster kendt som programmering til abstraktioner og ikke den faktiske implementering.

Klassen, som indledes med nøgleordet abstrakt, kan indeholde både abstrakte og ikke-abstrakte metoder. Men flere nedarvninger understøttes ikke i abstrakt klasse. Så du kan højst forlænge én abstrakt klasse.

Singleton objekter

En Singleton er en klasse, der kun instansieres én gang i et program. Det er fra et populært og nyttigt programmeringsmønster kendt som "singleton-mønsteret". Det er nyttigt til at skabe forekomster, der er beregnet til at være langtidsholdbare og vil være almindeligt tilgængelige i hele dit program, hvis tilstand er integreret i koordineringen af ​​begivenhederne i et system. Det er nemt at oprette en sådan klasse i Scala, da Scala giver os en enkel måde at oprette singletons ved hjælp af objekt-nøgleordet.

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

Vi kan derefter henvise til dette objekt i hele vores program med garanti for, at alle dele af vores program vil se de samme data, da der kun er én forekomst af det.

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

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

Konceptet med statiske medlemmer er der ikke i Scala, det er grunden til, at du skal bruge singleton-objekter, som fungerer som statiske medlemmer af en klasse.

Implicitte klasser

Implicitte klasser er den nye funktionalitet tilføjet efter version 2.1. Det er primært for at tilføje ny funktionalitet til de lukkede klasser.

Det implicitte nøgleord skal defineres i en klasse, et objekt eller et træk. Den primære konstruktør af en implicit klasse skal have præcis ét argument i sin første parameterliste. Den kan også indeholde en ekstra implicit parameterliste.

I nedenstående Scala-eksempel tilføjes ny funktionalitet til at erstatte vokaler i en streng med *.

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

Du skal importere i den klasse, hvor du bruger det.

import StringUtil.StringEnhancer

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

Objektorienteret programmering (OOP) vs. funktionel programmering (FP)

I OOP er programmer konstrueret ved at gruppere data og de funktioner, der fungerer på disse data, i stærkt forbundne enheder. Objekter bærer deres data i de felter og metoder, der opererer på dem. I denne programmeringsstil er hovedabstraktionen dataene, da de metoder, der oprettes, er beregnet til at operere på dataene.

Funktionel programmering, på den anden side adskiller data og de funktioner, der opererer på dataene. Dette gør det muligt for udviklere at behandle funktioner som abstraktionen og drivkraften ved modellering af programmer.

Scala muliggør funktionel programmering ved at have funktioner som førsteklasses borgere, så de kan overføres som værdier til andre funktioner og også returneres som værdier. Kombinationen af ​​disse to paradigmer har gjort Scala til et godt valg til at bygge kompleks software i forskellige brancher, såsom Data Science.

Vigtige rammer på Scala

Her er nogle vigtige rammer for Scala

• Leg er en open source webapplikationsramme, der bruger MVC arkitektur. Udgivet i 2007 og nu licenseret under Apache, blev det det mest populære framework på GitHub i 2013. Virksomheder som LinkedIn, Walmart, Samsung, Eero bruger dette framework.
• Elevator er et andet gratis web-framework skrevet i Scala, lanceret i 2007. Foursquare bruger Lift-rammen. Det er højtydende, hurtigere at bygge rammer.
• Som
• Katte
• Spark

Samtidig support

• Værdierne i Scala er som standard uforanderlige. Dette gør det meget tilpasningsdygtigt til det samtidige miljø.
• Der er mange funktioner i Scala, der gør den bedst til samtidige applikationer.
• Futures and Promises gør det lettere at behandle data asynkront og understøtter dermed parallelitet.
• Akka – værktøjssæt, der bruger Actor samtidighedsmodel. Der er en række skuespillere, der handler, når de modtager beskeder.
• Samtidig brug af tråde fra Java kan også understøttes i Scala.
• Streambehandling er en anden fantastisk funktion, der muliggør kontinuerlig realtidsbehandling af data.

Scala har nogle af de bedste samtidighedsbiblioteker i Java økosystem.

• Native Java tråde
• Fibre fra biblioteker som Vertex
• ZIO – et bibliotek, der har primitiver til at hjælpe os med at håndtere samtidighed og asynkron beregning
• STM – Transaktion
• Fremtid – indbygget i Scala-sproget

Java vs. Scala

Her er de vigtigste forskel mellem Java og Scala.

Scala	Java
Mere kompakt og kortfattet	Forholdsvis større bidder af kode
Designet og udviklet til at være både objekt- og funktionsorienteret sprog. Understøtter en lang række funktionelle programmeringsfunktioner såsom samtidighed, uforanderlighed.	Oprindeligt udviklet som et objektorienteret sprog og begyndte at understøtte funktionelle programmeringsfunktioner i de seneste dage. Stadig er ikke stærk som et funktionelt programmeringssprog.
Bruger skuespillermodel til at understøtte samtidighed, som er moderne	Bruger den konventionelle trådbaserede model til samtidighed.
Understøtter rammer – leg, løft	Understøtter fjeder, grale, meget mere
Understøtter doven evaluering	Understøtter ikke doven evaluering
Ingen statiske medlemmer	Indeholder statiske medlemmer
Understøtter operatøroverbelastning	Understøtter ikke operatøroverbelastning
Kompilering af kildekode er forholdsvis langsom	Kompilering af kildekode er hurtigere end Scala
Træk – opfør dig som Java 8 grænseflader	Java 8 grænseflader forsøger at bygge bro mellem klasser og grænseflader
Omskrivning er nødvendig	Genskrivning er ikke påkrævet
Ingen sikkerhed for de fejlfrie koder	Fuldstændig sikkerhed for mindre defekter
Understøtter bagudkompatibilitet.	Scala understøtter ikke bagudkompatibilitet.
Operators behandles forskelligt i Java og er ikke metodekald.	Alle operatører på indtastninger er via en metode kaldet i Scala.
Understøtter flere arv ved brug af klasser, men ikke af abstrakte klasser	Understøtter ikke flere nedarvninger ved hjælp af klasser, men efter grænseflader
Koden er skrevet i en kompakt form.	Koden er skrevet i lang form.
Scala indeholder ikke det statiske søgeord.	Java indeholder det statiske nøgleord.

Resumé

I denne vejledning har du lært, hvordan du kommer i gang med Scala. Du har også lært de funktionelle og objektorienterede funktioner. Du har også opdaget lighederne og forskellene mellem Java og Scala. Denne tutorial burde have hjulpet dig med en lang række eksempler, der er godt demonstreret.