Scala-veiledning: Scala-programmeringsspråkeksempel og kode
Oppsummering av Scala-opplæringen
Denne scala-opplæringen dekker alle aspekter og emner ved scala. Du vil lære alt det grunnleggende fra bunnen av som Hva er scala, installasjonsprosessen for scala, Scala-programmer, Scala-funksjoner, Lazy-evaluering, Typegrensesnitt, klasser og objekter, Arv, Abstraksjoner, Java og skalaforskjeller osv.
Hva er Scala?
Skala er et statisk skrevet programmeringsspråk som inkluderer både funksjonell og objektorientert programmering for å øke skalerbarheten til applikasjoner. Scala kjører primært på JVM-plattformen, og den kan også brukes til å skrive programvare for native plattformer ved å bruke Scala-Native og JavaScript kjøretider gjennom ScalaJs.
Scala er et skalerbart språk som brukes til å skrive programvare for flere plattformer. Derfor fikk den navnet "Scala". Dette språket er ment å løse problemene med Java samtidig som den er mer kortfattet. Opprinnelig designet av Martin Odersky, ble den utgitt i 2003.
Hvorfor lære Scala
Her er de viktigste grunnene til å lære Scala-programmeringsspråket:
- Scala er lett å lære for objektorienterte programmerere, Java utviklere. Det er i ferd med å bli et av de populære språkene de siste årene.
- Scala tilbyr førsteklasses funksjoner for brukere
- Scala kan utføres på JVM, og baner dermed vei for interoperabilitet med andre språk.
- Den er designet for applikasjoner som er samtidige, distribuerte og spenstige meldingsdrevne. Det er et av de mest krevende språkene i dette tiåret.
- Det er kortfattet, kraftig språk og kan raskt vokse i henhold til etterspørselen til brukerne.
- Den er objektorientert og har mange funksjonelle programmeringsfunksjoner som gir utviklerne mye fleksibilitet til å kode på en måte de ønsker.
- Scala tilbyr mange andetyper
- Den har mindre boilerplate hvis du kommer fra Java
- Rammene Lift and Play skrevet i Scala er i vekstkurven.
Hvordan installere Scala
For å begynne å skrive Scala-programmer, må du ha det installert på datamaskinen. For å gjøre dette, må du besøke nettstedet deres https://www.scala-lang.org/download/ for å laste ned den nyeste versjonen av Scala.
Ved å følge lenken blir vi ledet til to alternativer som vi kan velge for å installere Scala på maskinene våre. For denne Scala-opplæringen laster vi ned IntelliJ IDEA.
Når du besøker nedlastingslenken, vil du finne to versjoner av IntelliJ IDE.
For denne Scala-opplæringen laster vi ned Community Edition, som er gratis og kommer med alt du trenger for å skrive Scala-programmer.
Trinn 1) Velg Community Edition
På siden klikker du på rullegardinmenyen på fellesskapsutgaven.
Det gir oss en mulighet til å laste ned IntelliJ IDE sammen med JBR som inneholder en JDK-implementering(Java Development Kit) OpenJDK som Scala trenger for å kompilere og kjøre koden.
Trinn 2) Kjør installasjonen
Når du har lastet ned IntelliJ, dobbeltklikker du på den for å kjøre installasjonsveiviseren og følger dialogboksen.
Trinn 3) Velg et sted
Velg et sted for å installere IDE.
Hvis du tilfeldigvis ikke lastet ned den med JDK, får vi fortsatt en melding der vi kan sjekke for å laste den ned ved å merke av i avmerkingsboksen.
Trinn 4) Klikk på neste
La de andre standardinnstillingene være som de er, og klikk på Neste.
Trinn 5) Klikk på oppstartsikonet
Når installasjonen er fullført, kjør IntelliJ IDE ved å klikke på oppstartsikonet i oppstartsmenyen som et vanlig program.
Du må fortsatt gå gjennom et ekstra trinn med å legge til Scala-pluginen til IntelliJ; du gjør det ved å klikke på rullegardinmenyen på konfigureringsmenyen nederst til høyre på skjermen og velge plugin-alternativet.
På Marketplace-fanen vil et søk etter Scala presentere plugin-en som det første resultatet under Languages-taggen.
Trinn 6) Installer plugin
Klikk installer, som vil lede plugin-en til å starte nedlastingen.
Trinn 7) Start IDE på nytt
Etter at nedlastingen er fullført, blir du bedt om å starte IDE-en på nytt slik at den installerte plugin-en kan begynne å fungere.
Etter omstart vil du finne deg selv på samme side som før da vi kjørte IDE, men denne gangen har vi allerede installert Scala-plugin.
Scala Hello World-programmet
Trinn 1) Velg alternativet Opprett prosjekt, som fører oss til en side der vi kan velge hva slags språk prosjektet vårt skal bruke.
Trinn 2) velg Scala ved å merke av for Scala og klikk neste.
Trinn 3) Velg et sted for å lagre prosjektfilen vår og gi prosjektet et navn.
Hvis katalogen ikke eksisterer, vil IntelliJ be oss om å be oss om tillatelse til å opprette mappen. Godta og klikk på Fullfør. Du vil bli tatt til Scala-prosjektet ditt, som for øyeblikket ikke har noen Scala-kode.
Det vil ta litt tid å laste noen indekser, så ikke bekymre deg hvis du ikke umiddelbart kan gjøre noe mens det er en fremdriftslinje nederst på IDE-en din, det betyr ganske enkelt at IDE-en din laster inn noen filer som er nødvendige for å kjøre Scala og hjelp med IDE-autofullføring.
Trinn 4) Deretter klikker vi på prosjektfanen til venstre for IDE og utvider slik at vi kan se innholdet i prosjektet vårt.
For øyeblikket er prosjektet tomt og inneholder kun en .idea-mappe og hello-world.iml-fil generert av IDE. Vårt interessepunkt er src-mappen. Src er der vi lagrer kildekoden for prosjektet vårt. Det er her vi skal lage vår første Scala-fil.
Trinn 5) Høyreklikk på src for å åpne en meny for å lage en ny Scala-fil.
Vi vil da lage et navn for filen, i denne Scala-opplæringen bruker vi hello og velger deretter fra en rullegardin hva som skal angis som innholdet i Scala-filen. Velg "Objekt"
Når vi gjør dette, har vi en Scala-fil som har et Singleton-objekt som vi bruker til å kjøre koden vår.
Nå som du har en Scala-fil med et Hello-objekt. Du vil skrive ditt første program ved å utvide objektet du har laget ved å bruke app-nøkkelordet.
Utvidelse av objektet vårt med App fortell kompilatoren hvilken kode som skal kjøres når den starter programmet. Umiddelbart etter utvidelse av appen, vises en grønn pil på venstre side, som indikerer at du nå kan kjøre programmet.
Inne i Hello-objektet skriver vi én funksjon println() som brukes til å skrive ut teksten inne i det til konsollen. Vi kjører koden vår ved å klikke på den grønne pilen.
Ved å klikke på pilen får vi alternativet Kjør, hei, når du klikker på det, vil koden vår begynne å kompilere og etter noen sekunder vil vi se resultatene av programmet vårt skrevet ut fra konsollen som er innebygd i IntelliJ IDE.
Og nå har vi installert Scala og kjørt vårt første program.
Hva du kan gjøre med Scala
- Frontend webutvikling med ScalaJS
- Mobilutvikling, begge deler Android Utvikling og IOS – med Scala Native
- Serversidebiblioteker som HTTP4S, Akka-Http, Play Framework
- Internett av ting som bruker
- Spillutvikling
- NLP – Natural Language Processing ved hjelp av en pakke med biblioteker ScalaNLP
- Testing av avanserte programmeringsteknikker som funksjonell programmering og i objektorientert programmering
- Bygg svært samtidig kommunikasjonsapplikasjon ved å bruke skuespillere et bibliotek for JVM inspirert av Erlang
- Bruk den til maskinlæring ved å bruke biblioteker som Figaro som gjør sannsynlighetsprogrammering og Apache Spark Det
Anonyme funksjoner
Scala-språket har anonyme funksjoner, som også kalles funksjonsbokstaver. At Scala er et funksjonelt språk betyr ofte at utviklere bryter ned store problemer i mange små oppgaver og lager mange funksjoner for å løse disse problemene. For å gjøre det enkelt å lage funksjoner inneholder Scala disse funksjonene som kan være instansiert uten navn. Vi kan tilordne dem direkte til variabler eller definisjoner 'def' som vist i Scala-eksemplet nedenfor:
val multiplyByTwo = (n:Int) => n * 2 def multiplyByThree = (n:Int) => n *3
Vi kan da bruke den vanlige måten vi bruker funksjoner ved å sende parametere til dem som følger.
multiplyByTwo(3) //6 multiplyByThree(4) //12
Disse metodene kommer godt med når vi ønsker å ha en ren og kortfattet kode. Vi kan bruke anonyme funksjoner når vi definerer metoder som ikke er store og ikke krever mye kode i kroppen. De er veldig enkle og trenger ikke en seremoni for å lage.
Disse metodene er ikke begrenset til funksjoner med argumenter og kan brukes til å instansiere metoder som ikke tar inn noen argumenter.
val sayHello = ()=>{ println("hello") }
De fleste av disse anonyme funksjonene brukes i andre deler av koden vår hvor vi må opprette en rask funksjon på plass.
En annen grunn til at disse funksjonene også omtales som innebygde funksjoner. Å bruke anonyme funksjoner er et vanlig mønster som brukes gjennomgående i samlingsbiblioteket for å utføre raske handlinger over en samling.
For eksempel har vi filtermetoden som tar en innebygd funksjon/anonym funksjon for å lage en annen samling med bare elementer som oppfyller kriteriene vi definerer i den anonyme funksjonen.
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 metodene vi har som anonyme funksjoner de som sjekker om verdien vi får fra listen er oddetall og jevn 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å mulig å bruke jokertegn der parameteren til vår anonyme funksjon ikke er navngitt. For eksempel
var timesTwo = (_:Int)*2 timesTwo(5) //10
I dette scenariet navngir vi ikke parameteren vi sender inn. Det eneste vi bruker et understrek for å representere det.
Lat evaluering
De fleste språk evaluerer sekvensielt variabler og funksjonsparametere, etter hverandre. I Scala har vi et nøkkelord kalt lat, som hjelper til med å håndtere verdier vi ikke ønsker skal evalueres før de er referert.
En variabel merket som lat vil ikke bli evaluert der den er definert, det er vanligvis kjent som ivrig evaluering, den vil bare bli evaluert når det refereres til den senere i koden.
Dette kan være nyttig når evaluering av en verdi kan være en kostbar beregning, hvis det ikke er slik at verdien alltid er nødvendig, kan vi spare oss for å kjøre en dyr beregning som kan bremse programvaren vår ved å gjøre variabelen vår lat.
lazy val myExpensiveValue = expensiveComputation def runMethod()={ if(settings == true){ use(myExpensiveValue) }else{ use(otherValue) } }
Dette er ikke den eneste brukssaken for late variabler. De hjelper også med å håndtere problemer med sirkulær avhengighet i kode.
I tilfelle innstillingene er falske, trenger vi kanskje ikke bruke myExpensiveValue, noe som kan føre til at vi slipper å gjøre en kostbar beregning som bidrar til å sikre at brukerne har det hyggelig å bruke applikasjonen vår, da våre andre behov kan beregnes riktig uten å overvelde RAM-en.
I tilfelle innstillingene er falske, trenger vi kanskje ikke å bruke myExpensiveValue, noe som kan føre til at vi sparer oss fra å gjøre en kostbar beregning som bidrar til å sikre at brukerne har det hyggelig å bruke applikasjonen vår, da våre andre behov kan beregnes på riktig måte uten å overvelde RAM-en.
Dovenskapen hjelper også med funksjonsargumenter, der argumentene bare brukes når de refereres til inne i funksjonen. Dette konseptet kalles Call-by-name-parametere.
def sometimesUsedString(someValue:String, defaultValue:=> String)={ if(someValue != null){ use(defaultValue) }else{ use(someValue) } }
Mange språk bruker call-by-value-metoden for å evaluere argumenter. Parameteren som sendes gjennom call-by-name vil kun bli evaluert ved behov i funksjonskroppen og vil ikke bli evaluert før det. Når verdien er evaluert, lagres den og kan brukes på nytt senere uten at den må revurderes. Et konsept som er kjent som memoization.
Skriv inferens
I Scala trenger du ikke å deklarere typer for hver variabel du oppretter. Dette er fordi Scala-kompilatoren kan gjøre typeslutning om typer basert på evaluering av høyresiden. Dette gjør at koden din kan være mer kortfattet – det frigjør oss fra å skrive standarder der den forventede typen er åpenbar
var first:String = "Hello, " var second:String = "World" var third = first + second //the compile infers that third is of type String
Høyere ordensfunksjon
En høyere-ordens funksjon er en funksjon som kan ta funksjoner som argumenter og kan returnere en funksjon som en returtype. I Scala regnes funksjoner som førsteklasses borgere. Ved å bruke disse funksjonene på denne måten kan vi være svært fleksible i hva slags programmer vi kan lage. Vi kan lage funksjoner dynamisk og mate inn funksjonalitet dynamisk til andre funksjoner.
def doMathToInt(n:Int, myMathFunction:Int=>Int): Int ={ myMathFunction(n) }
I funksjonen ovenfor sender vi inn en int og en funksjon som tar en int og returnerer en int. Vi kan sende inn hvilken som helst funksjon av signaturen. Med signatur mener vi en funksjons input og output. En signatur av Int=>Int betyr at en funksjon tar en Int som input og returnerer en Int som sin utgang.
En signatur på ()=>Int betyr at en funksjon ikke tar noe som den er input og returnerer en Int som sin utgang. Et eksempel på en slik funksjon ville være en som genererer en tilfeldig int for oss.
def generateRandomInt()={ return scala.util.Random.nextInt() }
Funksjonen ovenfor har en signatur ()=>Int
Vi kan ha en funksjon som har en signatur scala ()=>Enhet. Dette betyr at funksjonene ikke tar inn noe og ikke returnerer en type. Funksjonen kan være å gjøre en slags beregning ved å endre noe til å gjøre noe forhåndsbestemt.
Slike metoder oppmuntres imidlertid ikke, da de ser ut til å være en svart boks som kan påvirke et system på noen ukjente måter. De er også untestable. Å ha eksplisitte input- og output-typer gjør det mulig for oss å resonnere om hva funksjonen vår gjør.
En høyere ordens funksjon kan også returnere en funksjon.
For eksempel kan vi lage en metode som vil lage en kraftfunksjon, dvs. tar et tall og bruker kraft til det.
def powerByFunction(n:Int):Int=>Int = { return (x:Int)=> scala.math.pow(x,n).toInt }
Funksjonen ovenfor tar en int. Vår returtype er en anonym funksjon som tar en Int x, * vi bruker int x som argument for potensfunksjonen.
Currying
I Scala kan vi konvertere en funksjon som tar to argumenter til en som tar ett argument om gangen. Når vi sender inn ett argument, bruker vi det delvis og ender opp med en funksjon som tar ett argument for å fullføre funksjonen. Currying gjør det mulig for oss å lage funksjoner ved å delvis legge til noen argumenter.
Dette kan være nyttig for å lage funksjoner dynamisk før vi har et komplett sett med argumenter
def multiply two numbers(n:Int)(m:Int): Unit ={ return n * m }
Hvis vi trenger å lage en funksjon som multipliserer med et bestemt tall, trenger vi ikke lage en annen multiplikasjonsmetode.
Vi kan ganske enkelt kalle .curried på funksjonen vår ovenfor og få en funksjon som tar ett argument først og returnerer en delvis anvendt funksjon
def multiplyTwoNumbers(n:Int)(m:Int): Unit ={ return n * m } var multiplyByFive = multiplyTwoNumbers(5) multiplyByFive(4) //returns 20
Mønster Matching
Scala har en kraftig innebygd mekanisme for å hjelpe oss å sjekke om en variabel samsvarer med visse kriterier, omtrent som vi ville gjort i en switch-setning i Java eller i en serie med if/else-utsagn. Språket har mønstertilpasning som vi kan bruke for å sjekke om en variabel er av en bestemt type. Mønstertilpasning i Scala er kraftig og kan brukes til å destrukturere komponentene som har en ikke-anvendende metode for å få felt vi er interessert i direkte fra variabelen vi matcher.
Scalas mønstertilpasning gir også en mer 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 variabelen vår med et sett med alternativer, og når variabelen vi matcher oppfyller kriteriene, evalueres uttrykket på høyre side av fettpilen (=>) og returneres som resultatet av treffet.
Vi bruker et understrek for å fange opp tilfeller som er uovertruffen i koden vår. Den gjenspeiler oppførselen til standardsaken når du håndterer brytersetninger.
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 kan du finne ut typen myItem-variabel og basert på den forgrene deg til en bestemt kode.
Mønstertilpasning sjekker om variabelen samsvarer
Understrekingen fungerer som en plassholder som samsvarer med alle andre forhold som ikke samsvarer med de andre elementene i saksuttalelsene ovenfor. Vi tar en variabel myItem og kaller matchmetoden.
- vi sjekker om myItem er sant ved å bruke og gjør litt logikk på høyre side av fettpilen "=>."
- vi bruker understrekingen for å matche noe som ikke samsvarer med noen av saksuttalelsene vi har definert i koden.
Med Case-klasser kan vi til og med gå lenger og destrukturere klassen for å få felt inne i objektet.
Ved å bruke det forseglede nøkkelordet for å definere klassene våre, får vi fordelen av å la kompilatoren sjekke sakene vi prøver å matche mot og advare oss hvis vi glemmer å håndtere en bestemt sak.
Uforanderlighet
Det er mulig å lage verdier som ikke kan endres av andre funksjoner i Scala ved å bruke val-nøkkelordet. Dette oppnås i Java ved å bruke det siste nøkkelordet. I Scala gjør vi det ved å bruke et val nøkkelord når vi lager en variabel i stedet for å bruke var, som er alternativet vi ville brukt for å lage en variabel variabel.
En variabel definert ved hjelp av nøkkelordet val er skrivebeskyttet, mens en som er definert med var kan leses og endres av andre funksjoner eller vilkårlig av brukeren 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
Hvis du prøver å tilordne en verdi til myNumber etter at vi har erklært den som en val, får du en kompileringsfeil eller "omtilordning til val."
Hvorfor bruke Immutability?
Uforanderlighet hjelper oss å forhindre at kode og andre programmerere endrer verdiene våre uventet, noe som vil føre til uventede resultater hvis de er ment å bruke verdien vi lagrer, kan de i stedet lage en kopi av den. På denne måten forhindres feil som kan være forårsaket av at flere aktører endrer samme variabel.
Klasser og objekter
Vi vet alle at objekter er de virkelige enhetene, og klasse er en mal som definerer objekter. Klasser har både tilstand og atferd. Tilstandene er enten verdier eller variabler. Atferdene er metodene i Scala.
La oss se på hvordan du kan definere en klasse, instansiere den og bruke den ved hjelp av Scala.
Her er klassen kalt rektangel, som har to variabler og to funksjoner. Du kan også bruke parameterne l og b direkte som felt i programmet. Du har et objekt som har en hovedmetode og har instansiert klassen med to verdier.
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 feltene og metoden er som standard offentlige i Scala. Det er viktig å bruke overstyring fordi toString-metoden er definert for Object i Scala.
Arv
Scala har flere typer arv (som enkelt, flernivå, multiple, hierarkiske, hybrid) som har mye til felles med tradisjonelle former som finnes i Java. Du kan arve både fra klasser og egenskaper. Du kan arve medlemmene av en klasse inn i en annen klasse ved å bruke nøkkelordet "utvider". Dette muliggjør gjenbruk.
Det er mulig å arve fra én klasse eller flere klasser. Det er også mulig å arve fra underklasser som selv har sine superklasser, og skaper et hierarki av arv i prosessen.
I Scala-eksemplet nedenfor er Base-klassen Circle, og avledet klasse er Sphere. En sirkel har en verdi kalt radius, som er arvet i Sphere-klassen. Metoden calcArea overstyres ved hjelp av nøkkelordet overstyring.
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 } }
Abstraksjon
I Scala kan vi lage abstrakte metoder og medlemsfelt ved å bruke abstrakte klasser og egenskaper. Inne i abstrakte klasser og egenskaper kan vi definere abstrakte felt uten å nødvendigvis 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 feltene er implementert av klassene som utvider egenskapen eller den abstrakte klassen. Du kan bruke egenskaper til å lage kontrakter om hva applikasjonen vår skal kunne gjøre, og deretter implementere disse metodene senere.
trait DatabaseService{ def addItemName(itemName:String) def removeItem(itemId:Int) def updateItem(itemId:Int, newItemName:String) }
På denne måten kan vi planlegge hvordan applikasjonen vår vil se ut uten å implementere metodene som kan hjelpe oss å se for oss hvordan ulike metoder vil se ut. Det følger langs et mønster kjent som programmering til abstraksjoner og ikke selve implementeringen.
Klassen som er innledet med nøkkelordet abstrakt kan inneholde både abstrakte og ikke-abstrakte metoder. Men flere arv støttes ikke i abstrakt klasse. Så du kan utvide maksimalt én abstrakt klasse.
Singleton objekter
En Singleton er en klasse som bare instansieres én gang i et program. Det er fra et populært og nyttig programmeringsmønster kjent som "singleton-mønsteret". Det er nyttig for å lage forekomster som er ment å være langvarige, og som vil være vanlig tilgjengelig i hele programmet hvis tilstand er integrert i koordineringen av hendelsene i et system. Det er enkelt å lage en slik klasse i Scala, siden Scala gir oss en enkel måte å lage singletoner ved å bruke objektnøkkelordet.
object UserProfile{ var userName="" var isLoggedIn:Boolean = false }
Vi kan deretter referere til dette objektet gjennom hele programmet med garanti for at alle deler av programmet vil se de samme dataene, siden det bare er én forekomst av det.
def getLoggedInStatus():Boolean={ return UserProfile.isLoggedIn } def changeLoggedInStatus():Boolean={ UserProfile.isLoggedIn = !UserProfile.isLoggedIn return UserProfile.isLoggedIn }
Konseptet med statiske medlemmer er ikke der i Scala, det er grunnen til at du må bruke singleton-objekter, som fungerer som statiske medlemmer av en klasse.
Implisitte klasser
Implisitte klasser er den nye funksjonaliteten lagt til etter versjon 2.1. Det er først og fremst for å legge til ny funksjonalitet til de lukkede klassene.
Det implisitte nøkkelordet bør defineres i en klasse, et objekt eller en egenskap. Primærkonstruktøren til en implisitt klasse bør ha nøyaktig ett argument i sin første parameterliste. Den kan også inkludere en ekstra implisitt parameterliste.
I Scala-eksemplet nedenfor er ny funksjonalitet for å erstatte vokaler til en streng med * lagt til.
object StringUtil { implicit class StringEnhancer(str: String) { def replaceVowelWithStar: String = str.replaceAll("[aeiou]", "*") } }
Du må importere i klassen der du bruker den.
import StringUtil.StringEnhancer object ImplicitEx extends App { val msg = "This is Guru99!" println(msg.replaceVowelWithStar) }
Objektorientert programmering (OOP) vs. funksjonell programmering (FP)
I OOP er programmer konstruert ved å gruppere data og funksjonene som opererer på disse dataene i høyt tilkoblede enheter. Objekter bærer dataene sine i feltene og metodene som opererer på dem. I denne programmeringsstilen er hovedabstraksjonen dataene, da metodene som lages er ment å operere på dataene.
Funksjonell programmering, derimot, skiller data og funksjonene som opererer på dataene. Dette gjør det mulig for utviklere å behandle funksjoner som abstraksjonen og drivkraften ved modellering av programmer.
Scala muliggjør funksjonell programmering ved å ha funksjoner som førsteklasses borgere, slik at de kan overføres som verdier til andre funksjoner og også returneres som verdier. Kombinasjonen av disse to paradigmene har gjort Scala til et godt valg når det gjelder å bygge kompleks programvare i ulike bransjer, for eksempel Data Science.
Viktige rammer på Scala
Her er noen viktige rammer for Scala
- Spille er et åpen kildekode-nettapplikasjonsrammeverk som bruker MVC-arkitektur. Utgitt i 2007 og nå lisensiert under Apache, ble det det mest populære rammeverket på GitHub i 2013. Selskaper som LinkedIn, Walmart, Samsung, Eero bruker dette rammeverket.
- Heis er et annet gratis nettrammeverk skrevet i Scala lansert i 2007. Foursquare bruker Lift-rammeverket. Det gir høy ytelse, raskere å bygge rammeverk.
- Akka
- Katter
- Spark
Samtidig støtte
- Verdiene i Scala er som standard uforanderlige. Dette gjør den svært tilpasningsdyktig til det samtidige miljøet.
- Det er mange funksjoner i Scala som gjør det best for samtidige applikasjoner.
- Futures and Promises gjør det lettere å behandle data asynkront, og støtter dermed parallellisme.
- Akka – verktøysett som bruker Actor samtidighetsmodell. Det er en rekke skuespillere som handler når de mottar meldinger.
- Samtidig bruk av tråder fra Java kan også støttes i Scala.
- Strømbehandling er en annen flott funksjon som muliggjør kontinuerlig sanntidsbehandling av data.
Scala har noen av de beste samtidighetsbibliotekene i Java økosystem.
- Innfødt Java tråder
- Fibre fra biblioteker som Vertex
- ZIO – et bibliotek som har primitiver for å hjelpe oss med å håndtere samtidighet og asynkron beregning
- STM – Transaksjon
- Fremtid – innebygd i Scala-språket
Java mot Scala
Her er de viktigste forskjell mellom Java og Scala.
Skala | Java |
---|---|
Mer kompakt og konsis | Forholdsvis større kodebiter |
Designet og utviklet for å være både objekt- og funksjonsorientert språk. Støtter et bredt utvalg av funksjonelle programmeringsfunksjoner som samtidighet, uforanderlighet. |
Opprinnelig utviklet som et objektorientert språk og begynte å støtte funksjonelle programmeringsfunksjoner de siste dagene. Fortsatt er ikke sterkt som et funksjonelt programmeringsspråk. |
Bruker skuespillermodell for å støtte samtidighet som er moderne | Bruker den konvensjonelle trådbaserte modellen for samtidighet. |
Støtter rammer – lek, løft | Støtter fjær, gral, mye mer |
Støtter lat evaluering | Støtter ikke lat evaluering |
Ingen statiske medlemmer | Inneholder statiske medlemmer |
Støtter operatøroverbelastning | Støtter ikke operatøroverbelastning |
Kompilering av kildekode er relativt treg | Kompilering av kildekode er raskere enn Scala |
Egenskaper - oppfør deg som Java 8 grensesnitt | Java 8 grensesnitt prøver å bygge bro mellom klasser og grensesnitt |
Omskriving er nødvendig | Omskriving er ikke nødvendig |
Ingen garanti om de feilfrie kodene | Full sikkerhet for mindre feil |
Støtter bakoverkompatibilitet. | Scala støtter ikke bakoverkompatibilitet. |
Operators behandles forskjellig i Java og er ikke metodekall. | Alle operatører på oppføringer er via en metode kalt i Scala. |
Støtter flere arv ved bruk av klasser, men ikke av abstrakte klasser | Støtter ikke flere arv ved bruk av klasser, men etter grensesnitt |
Koden er skrevet i en kompakt form. | Koden er skrevet i lang form. |
Scala inneholder ikke det statiske nøkkelordet. | Java inneholder det statiske nøkkelordet. |
Oppsummering
I denne opplæringen har du lært hvordan du kommer i gang med Scala. Du har også lært de funksjonelle og objektorienterte funksjonene. Du har også oppdaget likhetene og forskjellene mellom Java og Scala. Denne opplæringen burde ha hjulpet deg med et bredt utvalg av eksempler som er godt demonstrert.