Vodič za Scalu: Primjer i kod za programski jezik Scala

Sažetak vodiča za Scalu

Ovaj vodič za scalu pokriva sve aspekte i teme o scali. Naučit ćete sve osnove od nule kao što su Što je scala, proces instalacije scale, Scala programi, Scala funkcije, Lazy evaluacija, Tip sučelja, klase i objekti, nasljeđivanje, apstrakcije, Java i skala razlike, itd.

Scala je skalabilni jezik koji se koristi za pisanje softvera za više platformi. Otuda je i dobila ime “Scala”. Ovaj jezik je namijenjen rješavanju problema Java dok je istovremeno koncizniji. U početku ga je dizajnirao Martin Odersky, a objavljen je 2003.

Zašto učiti Scalu

Ovo su glavni razlozi za učenje Scala programskog jezika:

• Scala je jednostavna za naučiti objektno orijentirane programere, Java programeri. Posljednjih godina postaje jedan od popularnih jezika.
• Scala nudi prvorazredne funkcije za korisnike
• Scala se može izvršiti na JVM, čime se otvara put interoperabilnosti s drugim jezicima.
• Dizajniran je za aplikacije koje su istodobne, distribuirane i otporne i upravljane porukama. To je jedan od najzahtjevnijih jezika ovog desetljeća.
• Jezgrovit je, moćan jezik i može brzo rasti u skladu sa zahtjevima svojih korisnika.
• Objektno je orijentiran i ima puno funkcionalnih programskih značajki koje razvojnim programerima pružaju veliku fleksibilnost kodiranja na način na koji žele.
• Scala nudi mnoge vrste pataka
• Ima manje šablona ako dolazite iz Java
• Okviri Lift and Play napisani u Scali su u krivulji rasta.

Kako instalirati Scala

Da biste počeli pisati Scala programe, morate je imati instaliranu na vašem računalu. Da biste to učinili, morat ćete posjetiti njihovu stranicu https://www.scala-lang.org/download/ kako biste preuzeli najnoviju verziju Scale.

Slijedeći vezu, dolazimo do dvije opcije koje možemo odabrati za instaliranje Scale na naše strojeve. Za ovaj Scala vodič, preuzet ćemo IntelliJ IDEA.

Nakon što posjetite vezu za preuzimanje, pronaći ćete dvije verzije IntelliJ IDE-a.

Za ovaj Scala vodič, preuzet ćemo Community Edition, koji je besplatan i dolazi sa svime što vam je potrebno za pisanje Scala programa.

Korak 1) Odaberite Zajedničko izdanje
Na stranici kliknite padajući izbornik na Izdanje zajednice.

Predstavlja nam opciju preuzimanja IntelliJ IDE-a zajedno s JBR-om koji sadrži JDK implementaciju (Java Development Kit) OpenJDK koji Scala treba za kompajliranje i pokretanje koda.

Korak 2) Pokrenite instalaciju
Nakon što preuzmete IntelliJ, dvaput ga kliknite kako biste pokrenuli instalacijski čarobnjak i slijedite dijaloški okvir.

Korak 3) Odaberite lokaciju
Odaberite mjesto za instalaciju IDE-a.

Ako slučajno niste preuzeli onaj s JDK-om, svejedno ćemo dobiti upit gdje možemo provjeriti da ga preuzmemo odabirom potvrdnog okvira.

Korak 4) Kliknite na sljedeće
Ostale zadane postavke ostavite onakvima kakve jesu i kliknite Dalje.

Korak 5) Kliknite na ikonu pokretanja
Kada instalacija završi, pokrenite IntelliJ IDE klikom na njegovu ikonu za pokretanje u izborniku za pokretanje kao običnu aplikaciju.

I dalje morate proći kroz dodatni korak dodavanja Scala dodatka u IntelliJ; to činite klikom na padajući izbornik na konfiguracijskom izborniku koji se nalazi u donjem desnom kutu zaslona i odabirom opcije dodatka.

Na kartici Marketplace, pretraživanje za Scala prikazat će dodatak kao prvi rezultat pod oznakom Languages.

Korak 6) Instalirajte dodatak
Kliknite instaliraj, što će dovesti do početka preuzimanja dodatka.

Korak 7) Ponovno pokrenite IDE
Nakon što preuzimanje završi, od vas će se tražiti da ponovno pokrenete IDE kako bi instalirani dodatak mogao početi raditi.

Nakon ponovnog pokretanja naći ćete se na istoj stranici kao i prije kada smo pokrenuli IDE, ali ovaj put smo već instalirali Scala dodatak.

Program Scala Hello World

Korak 1) Odaberite opciju Create Project, koja će nas dovesti do stranice na kojoj možemo odabrati vrstu jezika koji će naš projekt koristiti.

Korak 2) odaberite Scala odabirom okvira za izbor Scala i kliknite dalje.

Korak 3) Odaberite mjesto za spremanje datoteke naših projekata i dajte našem projektu naziv.

Ako direktorij ne postoji, IntelliJ će nas pitati za dopuštenje za stvaranje mape. Prihvatite i kliknite završi. Bit ćete odvedeni na vaš Scala projekt, koji trenutno nema Scala kod.

Trebat će neko vrijeme da se učitaju neki indeksi pa ne brinite ako ne možete odmah ništa učiniti dok postoji traka napretka na dnu vašeg IDE-a, to jednostavno znači da vaš IDE učitava neke datoteke potrebne za pokretanje Scale i pomoć s IDE autocompleteom.

Korak 4) Zatim ćemo kliknuti na karticu projekata s lijeve strane IDE-a i proširiti je tako da možemo vidjeti sadržaj našeg projekta.

Trenutno je projekt prazan i sadrži samo mapu .idea i datoteku hello-world.iml koju je generirao IDE. Naša točka interesa je mapa src. Src je mjesto gdje pohranjujemo izvorni kod za naš projekt. Tu ćemo stvoriti našu prvu Scala datoteku.

Korak 5) Desnom tipkom miša kliknite src da biste otvorili izbornik za stvaranje nove Scala datoteke.

Zatim ćemo stvoriti naziv za datoteku, u ovom Scala vodiču koristit ćemo hello, a zatim s padajućeg izbornika odabrati što ćemo staviti kao sadržaj Scala datoteke. Odaberite "Objekt"

Kada to učinimo, imat ćemo Scala datoteku koja ima Singleton objekt koji ćemo koristiti za pokretanje našeg koda.

Sada kada imate Scala datoteku s objektom Hello. Napisat ćete svoj prvi program proširenjem objekta koji ste stvorili pomoću ključne riječi App.

Proširenje našeg objekta pomoću aplikacije recite kompajleru koji kod da pokrene kada pokrene vaš program. Odmah nakon proširenja aplikacije, zelena strelica se pojavljuje na lijevoj strani, što pokazuje da sada možete pokrenuti svoj program.

Unutar objekta Hello pišemo jednu funkciju println() koja se koristi za ispis teksta unutar njega na konzolu. Pokrenut ćemo naš kod klikom na zelenu strelicu.

Klikom na strelicu otvara nam se opcija Run, hello, nakon klika na nju, naš kod će se početi kompajlirati i nakon nekoliko sekundi vidjet ćemo rezultate našeg programa ispisane iz konzole koja je ugrađena u IntelliJ IDE.

I eto nas, uspješno smo instalirali Scalu i pokrenuli naš prvi program.

Što možete učiniti sa Scalom

• Frontend web razvoj sa ScalaJS
• Mobilni razvoj, oboje Android Razvoj i IOS – sa Scala Native
• Biblioteke na strani poslužitelja kao što su HTTP4S, Akka-Http, Play Framework
• Korištenje Interneta stvari
• Razvoj igara
• NLP – Obrada prirodnog jezika korištenjem paketa biblioteka ScalaNLP
• Testiranje naprednih tehnika programiranja kao što je funkcionalno programiranje i objektno orijentirano programiranje
• Izgradite visoko konkurentnu komunikacijsku aplikaciju koristeći aktere biblioteku za JVM nadahnutu Erlangom
• Koristite ga za strojno učenje koristeći biblioteke kao što je Figaro koji radi probabilističko programiranje i Apache Spark tu

Anonimne funkcije

Jezik Scala ima anonimne funkcije, koje se također nazivaju funkcijski literali. Budući da je Scala funkcionalan jezik, programeri često raščlanjuju velike probleme na mnogo malih zadataka i stvaraju mnoge funkcije za rješavanje tih problema. Kako bi se olakšalo stvaranje funkcija, Scala sadrži ove funkcije koje se mogu instancirano bez imena. Možemo ih dodijeliti izravno varijablama ili definicijama 'def' kao što je prikazano u Scala primjeru ispod:

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

Zatim možemo koristiti uobičajeni način na koji koristimo funkcije prosljeđujući im parametre kako slijedi.

multiplyByTwo(3)

//6

multiplyByThree(4)

//12

Ove metode su korisne kada želimo imati čist i koncizan kod. Možemo koristiti anonimne funkcije kada definiramo metode koje nisu velike i ne zahtijevaju puno koda u svom tijelu. Vrlo su jednostavni i nije im potrebna ceremonija za izradu.

Ove metode nisu ograničene na funkcije s argumentima i mogu se koristiti za instanciranje metoda koje ne primaju nikakve argumente.

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

Većina tih anonimnih funkcija koristi se u drugim dijelovima našeg koda gdje moramo stvoriti brzu funkciju na mjestu.

Još jedan razlog zašto se ove funkcije također nazivaju ugrađene funkcije. Korištenje anonimnih funkcija uobičajeni je obrazac koji se sveprisutno koristi u knjižnici zbirki za izvođenje brzih radnji nad zbirkom.

Na primjer, imamo metodu filtra koja uzima ugrađenu funkciju/anonimnu funkciju za stvaranje druge zbirke samo s elementima koji zadovoljavaju kriterije koje definiramo u anonimnoj funkciji.

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)

Ovdje su metode koje imamo kao anonimne funkcije one koje provjeravaju je li vrijednost koju dobivamo s popisa parna ili neparna i vraćaju stavku.

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

U Scali je također moguće koristiti zamjenske znakove tamo gdje parametri naše anonimne funkcije nisu imenovani. Na primjer

var timesTwo = (_:Int)*2

timesTwo(5)
//10

U ovom scenariju ne imenujemo parametar koji prosljeđujemo. Jedino što koristimo podvlaku da ga predstavimo.

Lijena evaluacija

Većina jezika sekvencijalno procjenjuje varijable i parametre funkcije, jedan za drugim. U Scali imamo ključnu riječ koja se zove lazy, koja pomaže u rješavanju vrijednosti za koje ne želimo da budu vrednovane dok se ne referenciraju.

Varijabla označena kao lijena neće biti procijenjena tamo gdje je definirana, to je obično poznato kao željna procjena, bit će procijenjena samo kada se na nju referencira nešto kasnije u kodu.

Ovo može biti od pomoći kada procjena vrijednosti može biti skupo računanje, ako nije slučaj da je vrijednost uvijek potrebna, možemo se spasiti od pokretanja skupog računanja koje može usporiti naš softver tako što će našu varijablu učiniti lijenom.

lazy val myExpensiveValue = expensiveComputation

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

Ovo nije jedini slučaj upotrebe lijenih varijabli. Oni također pomažu u rješavanju problema kružne ovisnosti u kodu.

U slučaju da su postavke lažne, možda nećemo trebati koristiti myExpensiveValue, što nas može dovesti do toga da nas spasi od skupog izračunavanja koje pomaže osigurati da se korisnici lijepo provedu koristeći našu aplikaciju jer se njihove druge potrebe mogu pravilno izračunati bez preopterećenja RAM-a.

U slučaju da su postavke netočne, možda nećemo trebati koristiti myExpensiveValue, što nas može dovesti do toga da nas spasi od skupog izračunavanja koje pomaže osigurati da se korisnici lijepo provode koristeći našu aplikaciju jer se njihove druge potrebe mogu izračunati na odgovarajući način bez preopterećenja RAM-a.

Lijenost također pomaže s argumentima funkcije, gdje se argumenti koriste samo kada se na njih upućuje unutar funkcije. Taj se koncept naziva parametrima poziva po imenu.

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

Mnogi jezici koriste način poziva prema vrijednosti za procjenu argumenata. Parametar proslijeđen kroz poziv po imenu bit će procijenjen samo kada je to potrebno u tijelu funkcije i neće se procijeniti prije toga. Nakon što se vrijednost procijeni, pohranjuje se i kasnije se može ponovno upotrijebiti bez potrebe za ponovnim vrednovanjem. Koncept koji je poznat kao memoizacija.

Tipski zaključak

U Scali ne morate deklarirati tipove za svaku varijablu koju stvorite. To je zato što prevodilac Scala može zaključivati ​​tipove na temelju procjene desne strane. To omogućuje da vaš kod bude koncizniji – oslobađa nas pisanja šablona gdje je očekivani tip očit

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

Funkcija višeg reda

Funkcija višeg reda je funkcija koja može uzeti funkcije kao argumente i može vratiti funkciju kao vrstu povrata. U Scali se funkcije smatraju građanima prvog reda. Korištenje ovih funkcija na ovaj način omogućuje nam da budemo vrlo fleksibilni u vrsti programa koje možemo napraviti. Možemo dinamički stvarati funkcije i dinamički unositi funkcionalnost u druge funkcije.

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

U gornjoj funkciji prosljeđujemo int i funkciju koja uzima int i vraća int. Možemo unijeti bilo koju funkciju tog potpisa. Pod potpisom mislimo na ulaz i izlaz funkcije. Signatura Int=>Int znači da funkcija uzima Int kao ulaz i vraća Int kao izlaz.

Potpis ()=>Int znači da funkcija ne uzima ništa kao svoj ulaz i vraća Int kao svoj izlaz. Primjer takve funkcije bila bi ona koja za nas generira nasumični int.

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

Gornja funkcija ima potpis ()=>Int

Možemo imati funkciju koja ima potpis scala ()=>Jedinica. To znači da funkcije ne preuzimaju ništa i ne vraćaju tip. Funkcija bi mogla raditi neku vrstu izračuna mijenjajući nešto u obavljanje nečeg unaprijed određenog.

Ovakve metode se ipak ne potiču jer se čini da su crna kutija koja može utjecati na sustav na neke nepoznate načine. Također se ne mogu testirati. Eksplicitni tipovi ulaza i izlaza omogućuju nam razmišljanje o tome što naša funkcija radi.

Funkcija višeg reda također može vratiti funkciju.

Na primjer, mogli bismo kreirati metodu koja će kreirati funkciju potenciranja, tj. uzeti broj i primijeniti na njega snagu.

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

Gornja funkcija uzima int. Naš povratni tip je anonimna funkcija koja uzima Int x, * koristimo int x kao argument za funkciju snage.

Kariranje

U Scali možemo pretvoriti funkciju koja uzima dva argumenta u jednu koja uzima jedan po jedan argument. Kada predamo jedan argument, djelomično ga primijenimo i završimo s funkcijom koja uzima jedan argument da dovrši funkciju. Currying nam omogućuje stvaranje funkcija djelomičnim dodavanjem argumenata.

Ovo može biti korisno za dinamičko stvaranje funkcija prije nego što imamo kompletan skup argumenata

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

Ako trebamo stvoriti funkciju koja se množi s nekim određenim brojem, ne moramo stvoriti drugu metodu množenja.

Možemo jednostavno pozvati .curried na našoj gornjoj funkciji i dobiti funkciju koja prvo uzima jedan argument i vraća djelomično primijenjenu funkciju

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

var multiplyByFive = multiplyTwoNumbers(5) 

multiplyByFive(4)

//returns 20

Usklađivanje uzoraka

Scala ima moćan ugrađeni mehanizam koji nam pomaže provjeriti odgovara li varijabla određenim kriterijima, slično kao što bismo učinili u naredbi switch u Java ili u nizu naredbi if/else. Jezik ima podudaranje uzoraka koje možemo koristiti da provjerimo je li varijabla određenog tipa. Usklađivanje uzorka u Scali je moćno i može se koristiti za destrukturiranje komponenti koje imaju metodu poništavanja primjene kako bismo dobili polja koja nas zanimaju izravno iz varijable koju uparujemo.

Scalino podudaranje uzoraka također pruža ugodniju sintaksu u usporedbi s naredbom switch.

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

Uspoređujemo našu varijablu sa skupom opcija, a kada varijabla koju uparujemo zadovolji kriterije, izraz na desnoj strani debele strelice (=>) procjenjuje se i vraća kao rezultat uparivanja.

Koristimo podvlaku kako bismo uhvatili slučajeve koji se ne podudaraju u našem kodu. Oslikava ponašanje zadanog slučaja kada se radi s naredbama 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 _ => //case we have a type we don't recognize do sth else
}

U gornjem kodu možete saznati vrstu varijable myItem i na temelju toga granati se na određeni kod.

Uparivanje uzorka provjerava podudara li se varijabla

Podvlaka funkcionira kao rezervirano mjesto koje odgovara bilo kojem drugom uvjetu koji se ne podudara s drugim stavkama u gornjim izjavama slučaja. Uzimamo varijablu myItem i pozivamo metodu podudaranja.

• provjeravamo je li myItem istinit koristeći i radimo neku logiku na desnoj strani debele strelice "=>."
• koristimo podvlaku za podudaranje sa svime što se ne podudara s bilo kojom od naredbi case koje smo definirali u kodu.

S Case klasama možemo čak ići dalje i destrukturirati klasu kako bismo dobili polja unutar objekta.

Korištenjem ključne riječi sealed za definiranje naših klasa, dobivamo korist od toga što prevodilac iscrpno provjerava slučajeve koje pokušavamo usporediti i upozorava nas ako zaboravimo obraditi određeni.

Nepromjenljivost

Moguće je stvoriti vrijednosti koje se ne mogu mijenjati drugim funkcijama u Scali pomoću ključne riječi val. To se postiže u Java korištenjem final ključne riječi. U Scali to činimo korištenjem ključne riječi val pri stvaranju varijable umjesto upotrebe var, što je alternativa koju bismo koristili za stvaranje promjenjive varijable.

Varijabla definirana pomoću ključne riječi val je samo za čitanje, dok se ona definirana pomoću var može čitati i mijenjati drugim funkcijama ili proizvoljno od strane korisnika u kodu.

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

Pokušaj dodjele vrijednosti momBroju nakon što smo ga deklarirali kao val izbacuje pogrešku tijekom kompilacije ili "ponovno dodjeljivanje vrijednosti".

Zašto koristiti nepromjenjivost?

Nepromjenjivost nam pomaže spriječiti kod i druge programere da neočekivano promijene naše vrijednosti, što bi dovelo do neočekivanih rezultata ako namjeravaju koristiti vrijednost koju pohranjujemo, umjesto toga je mogu kopirati. Na taj način se sprječavaju greške koje mogu biti uzrokovane višestrukim akterima koji mijenjaju istu varijablu.

Razredi i predmeti

Svi znamo da su objekti entiteti stvarnog svijeta, a klasa je predložak koji definira objekte. Klase imaju i stanje i ponašanja. Stanja su ili vrijednosti ili varijable. Ponašanja su metode u Scali.

Pogledajmo kako možete definirati klasu, instancirati je i koristiti pomoću Scale.

Ovdje je klasa pod nazivom Rectangle, koja ima dvije varijable i dvije funkcije. Također možete koristiti parametre l i b izravno kao polja u programu. Imate objekt koji ima glavnu metodu i instancirao je klasu s dvije vrijednosti.

Primjer:

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

Sva polja i metode su prema zadanim postavkama javni u Scali. Bitno je koristiti nadjačavanje jer je metoda toString definirana za Object u Scali.

Nasljeđivanje

Scala ima više tipova nasljeđivanja (kao jednostruko, višerazinsko, višestruko, hijerarhijsko, hibridno,) koji dijele mnogo toga zajedničkog s tradicionalnim oblicima koji se nalaze u Java. Možete naslijediti i klase i osobine. Možete naslijediti članove jedne klase u drugu klasu koristeći ključnu riječ "extends". To omogućuje ponovnu upotrebu.

Moguće je naslijediti iz jedne klase ili više klasa. Također je moguće naslijediti od podklasa koje same imaju svoje superklase, stvarajući hijerarhiju nasljeđivanja u procesu.

U Scala primjeru ispod, osnovna klasa je krug, a izvedena klasa je sfera. Krug ima vrijednost koja se zove radijus, a koja se nasljeđuje u klasi Sphere. Metoda calcArea nadjačava se pomoću ključne riječi override.

Primjer:

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

Apstrakcija

U Scali možemo kreirati apstraktne metode i polja članova koristeći apstraktne klase i značajke. Unutar apstraktnih klasa i značajki, možemo definirati apstraktna polja bez da ih nužno implementiramo.

Primjer:

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

Ova polja implementiraju klase koje proširuju značajku ili apstraktnu klasu. Možete koristiti značajke za stvaranje ugovora o tome što bi naša aplikacija trebala moći učiniti, a zatim implementirati te metode kasnije.

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

Na taj način možemo planirati kako će naša aplikacija izgledati bez implementacije metoda koje nam mogu pomoći da zamislimo kako će izgledati različite metode. Slijedi obrazac poznat kao programiranje do apstrakcija, a ne do stvarne implementacije.

Klasa kojoj prethodi ključna riječ abstract može sadržavati i apstraktne i neapstraktne metode. Ali višestruko nasljeđivanje nije podržano u apstraktnoj klasi. Dakle, možete proširiti najviše jednu apstraktnu klasu.

Pojedinačni objekti

Singleton je klasa koja se instancira samo jednom u programu. To je iz popularnog i korisnog obrasca programiranja poznatog kao "singleton pattern". Korisno je u stvaranju instanci koje su namijenjene da budu dugovječne i kojima će se uobičajeno pristupati kroz vaš program čije je stanje sastavni dio koordinacije događaja u sustavu. Stvaranje takve klase u Scali jednostavno je jer nam Scala pruža jednostavan način stvaranja pojedinačnih elemenata pomoću ključne riječi object.

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

Zatim možemo referencirati ovaj objekt kroz naš program uz jamstvo da će svi dijelovi našeg programa vidjeti iste podatke jer postoji samo jedna njegova instanca.

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

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

Koncept statičkih članova ne postoji u Scali, to je razlog zašto trebate koristiti singleton objekte, koji se ponašaju kao statički članovi klase.

Implicitne klase

Implicitne klase nova su funkcionalnost dodana nakon verzije 2.1. Prvenstveno je dodati nove funkcionalnosti zatvorenim razredima.

Implicitna ključna riječ treba biti definirana u klasi, objektu ili osobini. Primarni konstruktor implicitne klase trebao bi imati točno jedan argument u svojoj prvoj listi parametara. Također može uključivati ​​dodatnu implicitnu listu parametara.

U donjem primjeru Scale dodana je nova funkcionalnost za zamjenu samoglasnika niza sa *.

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

Morate uvesti u klasu u kojoj ga koristite.

import StringUtil.StringEnhancer

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

Objektno orijentirano programiranje (OOP) naspram funkcionalnog programiranja (FP)

U OOP programi se konstruiraju grupiranjem podataka i funkcija koje rade na tim podacima u visoko povezane jedinice. Objekti nose svoje podatke u poljima i metodama koje rade na njima. U ovom stilu programiranja, glavna apstrakcija su podaci jer su metode koje se stvaraju namijenjene za rad s podacima.

Funkcionalno programiranje, s druge strane, odvaja podatke i funkcije koje rade s podacima. To omogućuje programerima da tretiraju funkcije kao apstrakciju i pokretačku snagu pri modeliranju programa.

Scala omogućuje funkcionalno programiranje tako što ima funkcije kao građani prve klase, dopuštajući da se proslijede kao vrijednosti drugim funkcijama i da se također vrate kao vrijednosti. Kombinacija ovih dviju paradigmi učinila je Scalu odličnim izborom za izgradnju složenog softvera u raznim industrijama, kao što je Data Science.

Važni okviri na Scali

Ovdje su neki važni okviri Scale

• Igrati je okvir web aplikacije otvorenog koda koji koristi MVC arhitektura. Izdan 2007. i sada licenciran pod Apacheom, postao je najpopularniji okvir na GitHubu 2013. Tvrtke kao što su LinkedIn, Walmart, Samsung, Eero koriste ovaj okvir.
• Lift je još jedan besplatni web framework napisan u Scali pokrenut 2007. Foursquare koristi okvir Lift. Okvir je visokih performansi, brži za izgradnju.
• Acre
• Mačke - Leecork
• Spark

Podrška za istovremenost

• Vrijednosti u Scali su prema zadanim postavkama nepromjenjive. To ga čini vrlo prilagodljivim istovremenom okruženju.
• Postoji mnogo značajki u Scali koje je čine najboljom za istodobne aplikacije.
• Futures i Promises olakšavaju asinkronu obradu podataka, čime se podržava paralelizam.
• Akka – alat koji koristi model konkurentnosti Actor. Postoji niz glumaca koji djeluju kada prime poruke.
• Konkurentnost pomoću niti iz Java također može biti podržan u Scali.
• Stream obrada još je jedna sjajna značajka koja omogućuje kontinuiranu obradu podataka u stvarnom vremenu.

Scala ima neke od najboljih paralelnih biblioteka u Java ekosustava.

• Domorodac Java teme
• Vlakna iz knjižnica poput Vertexa
• ZIO – biblioteka koja ima primitive koji nam pomažu u suočavanju s konkurentnošću i asinkronim računanjem
• STM – Transakcija
• Budućnost – ugrađena u Scala jezik

Java protiv Scale

Evo glavnih razlika između Java i Scala.

Skala	Java
Kompaktniji i koncizniji	Relativno veći dijelovi koda
Dizajniran i razvijen da bude i objektno i funkcionalno orijentirani jezik. Podržava širok izbor značajki funkcionalnog programiranja kao što su konkurentnost, nepromjenjivost.	Izvorno razvijen kao objektno orijentirani jezik, a nedavno je počeo podržavati značajke funkcionalnog programiranja. Još uvijek nije jak kao funkcionalni programski jezik.
Koristi model glumca za podršku konkurentnosti što je moderno	Koristi konvencionalni model temeljen na nitima za istodobnost.
Podržava okvire – Play, Lift	Podržava Spring, Grails, mnogo više
Podržava lijeno ocjenjivanje	Ne podržava lijeno ocjenjivanje
Nema statičkih članova	Sadrži statične članove
Podržava preopterećenje operatera	Ne podržava preopterećenje operatera
Kompilacija izvornog koda relativno je spora	Kompilacija izvornog koda je brža od Scale
Osobine – ponašati se kao Java 8 sučelja	Java 8 sučelja pokušava premostiti jaz između klasa i sučelja
Potrebno je prepisivanje	Prepisivanje nije potrebno
Nema jamstva o kodovima bez grešaka	Potpuna garancija za manje nedostatke
Podržava kompatibilnost sa prethodnim verzijama.	Scala ne podržava povratnu kompatibilnost.
Operatorovi se različito tretiraju u Java i nisu pozivi metode.	Svi operatori na unosima rade putem metode koja se zove u Scali.
Podržava višestruko nasljeđivanje pomoću klasa, ali ne pomoću apstraktnih klasa	Ne podržava višestruko nasljeđivanje pomoću klasa, već po sučeljima
Kod je napisan u kompaktnom obliku.	Kod je napisan u dugom obliku.
Scala ne sadrži ključnu riječ static.	Java sadrži ključnu riječ static.

Rezime

U ovom vodiču ste naučili kako započeti sa Scalom. Također ste naučili funkcionalne i objektno orijentirane značajke. Također ste otkrili sličnosti i razlike između Java i Scala. Ovaj vam je vodič trebao pomoći sa širokim spektrom primjera koji su dobro demonstrirani.