Scala õpetus

Mis on Scala?

Scala on staatiliselt tüübitud programmeerimiskeel, mis ühendab objektorienteeritud ja funktsionaalse programmeerimise, et parandada rakenduste skaleeritavust. Scala töötab peamiselt JVM platvormil ja arendajad saavad seda kasutada ka tarkvara kirjutamiseks natiivsetele platvormidele Scala-Native'i kaudu või brauserile ScalaJ-i kaudu. JavaScript tööaeg.

Scala on skaleeritav keel, mida kasutatakse tarkvara loomiseks mitmele platvormile, mistõttu see oma nime saigi. Keel loodi mitmete sõnastusprobleemide lahendamiseks, mida leidub Java jäädes samas napisõnaliseks. Scala disainis Martin Odersky ja esimene avalik versioon ilmus 2004. aastal.

Miks õppida Scalat

Siin on peamised põhjused Scala programmeerimiskeele õppimiseks:

• Scala on objektorienteeritud programmeerijatele lihtne õppida ja Java arendajad ja sellest on viimastel aastatel saanud üks populaarsemaid keeli.
• Scala pakub kasutajatele esmaklassilisi funktsioone.
• Scala saab käivitada FMV, sillutades teed koostalitlusvõimele teiste keeltega.
• See on loodud rakenduste jaoks, mis on samaaegsed, hajutatud ja vastupidavad sõnumipõhised, mis teeb sellest selle kümnendi ühe nõutuma keele.
• See on kokkuvõtlik ja võimas keel, mis saab vastavalt kasutajate nõudmistele kiiresti kasvada.
• See on objektorienteeritud ja sisaldab palju funktsionaalseid programmeerimisfunktsioone, andes arendajatele palju paindlikkust koodi kirjutamisel.
• Scala pakub Duck Ty'dping struktuuritüüpide kaudu.
• Sellel on vähem standardset kujundust kui Java.
• Scalas kirjutatud raamistikud Lift and Play arenevad ja nende populaarsus kasvab pidevalt.

Kuidas installida Scala

Scala programmide kirjutamise alustamiseks peab see olema teie arvutisse installitud. Selleks külastage ametlikku veebisaiti aadressil https://www.scala-lang.org/download/ Scala uusima versiooni allalaadimiseks.

Lingile järgnevalt kuvatakse teile Scala installimiseks kaks võimalust. Selles Scala õpetuses kasutame järgmist IntelliJ IDEA, mis pakub kohe karbist võttes suurepärast Scala tuge.

Kui olete allalaadimislingile külastanud, leiate IntelliJ IDE kaks väljaannet.

Selle Scala õpetuse jaoks laadime alla kogukonnaväljaande, mis on tasuta ja sisaldab kõike, mida vajate Scala programmide kirjutamiseks.

Step 1) Valige kogukonnaväljaanne.
Klõpsake lehel rippmenüüd valikul Kogukonnaväljaanne.

See pakub võimalust alla laadida IntelliJ IDE koos JBR-iga, mis sisaldab JDK implementatsiooni (Java Development Kit), näiteks OpenJDK, mida Scala vajab koodi kompileerimiseks ja käivitamiseks.

Step 2) Käivitage install.
Kui olete IntelliJ alla laadinud, topeltklõpsake installijal ja järgige ekraanil kuvatavat viisardit.

Step 3) Valige asukoht.
Valige IDE installimise koht.

Kui te ei laadinud alla paketti koos JDK-ga, palub installija teil installimise ajal ikkagi JDK lisada märkeruudu kaudu.

Step 4) Klõpsake nuppu Edasi.
Jätke ülejäänud vaikesätted samaks ja klõpsake nuppu Edasi.

Programm Scala Hello World

Step 5) Klõpsake käivitusikoonil.
Kui installimine on lõppenud, käivitage IntelliJ IDE, klõpsates menüüs Start selle käivitusikoonil nagu tavaline rakendus.

Peate ikkagi Scala plugina IntelliJ-sse lisama. Klõpsake ekraani paremas alanurgas olevas konfiguratsioonimenüüs rippmenüüd ja valige suvand „Pluginad”.

Otsi vahekaardil Marketplace sõna „Scala“. Plugin kuvatakse esimese tulemusena silti „Languages“ all.

Step 6) Paigalda plugin.
Scala plugina allalaadimise alustamiseks klõpsake nuppu Installi.

Step 7) Taaskäivitage IDE.
Pärast allalaadimise lõppu palutakse teil IDE taaskäivitada, et installitud plugin saaks tööle hakata.

Pärast taaskäivitamist naasete samale lehele kui varem, kuid nüüd on Scala plugin installitud ja valmis.

Step 8) Valige „Loo projekt“, mis viib lehele, kus saate valida projekti keele.

Step 9) Valige Scala, märkides märkeruudu Scala ja klõpsates nuppu Edasi.

Step 10) Valige projektifaili salvestamiseks asukoht ja andke projektile nimi.

Kui kausta pole olemas, küsib IntelliJ luba kausta loomiseks. Nõustu ja klõpsa nupul „Valmis“. Seejärel suunatakse sind oma Scala projekti juurde, mis hetkel ei sisalda Scala koodi.

Indeksite laadimine võtab veidi aega, seega ärge muretsege, kui te ei saa IDE-ga suhelda, kui allosas kuvatakse edenemisriba. IDE laadib Scala käivitamiseks ja automaatse täitmise tagamiseks vajalikke faile.

Step 11) Projekti sisu nägemiseks klõpsake IDE vasakul küljel asuvat vahekaarti Projekt ja laiendage seda.

Sel hetkel on projekt tühi ja sisaldab ainult .idea kausta ja IDE loodud hello-world.iml faili. Huvipakkuv on src kaust, mis sisaldab projekti lähtekoodi. Siin lood oma esimese Scala faili.

Step 12) Paremklõpsake src-l, et avada menüü ja luua uus Scala fail.

Valige failile nimi. Selle Scala õpetuse jaoks kasutage tereja seejärel valige Scala faili sisutüübi rippmenüüst Objekt.

Kui olete selle teinud, on teil Scala fail, mis sisaldab üksikut objekti, mida kasutate koodi käivitamiseks.

Nüüd, kui sul on Scala fail Hello objektiga, kirjuta oma esimene programm, laiendades loodud objekti märksõna App abil.

Objekti laiendamine atribuudiga App annab kompilaatorile teada, millist koodi programmi käivitamisel käivitada. Kohe pärast atribuudi App laiendamist ilmub vasakule küljele roheline nool, mis näitab, et programm on nüüd käivitatav.

Kirjuta Hello objekti sisse funktsioon println(), mis prindib teksti konsoolile. Käivita programm rohelisele noolele klõpsates.

Noolele klõpsamine kuvab valiku „Käivita Hello”. Selle valimine kompileerib koodi ja mõne sekundi pärast ilmub programmi väljund IntelliJ konsoolile.

Nüüd olete Scala edukalt installinud ja oma esimese programmi käivitanud.

Mida saate Scalaga teha

Scalat kasutatakse oma paindlikkuse ja JVM-i koostalitlusvõime tõttu laialdaselt paljudes valdkondades. Levinumad kasutusjuhud on järgmised:

• Front-end veebiarendus ScalaJS-iga.
• Mobiiliarendus ettevõttele Android ja iOS Scala Native'iga.
• Serveripoolsed teegid nagu HTTP4S, Akka-Http ja Play Framework.
• Asjade interneti (IoT) rakendused.
• Mänguarendus.
• Looduskeele töötlemine ScalaNLP teekide komplekti abil.
• Edasijõudnute tehnikate, näiteks funktsionaalse programmeerimise ja objektorienteeritud programmeerimise koos harjutamine.
• Väga samaaegsed kommunikatsioonirakendused, mis kasutavad actoreid, Erlangist inspireeritud JVM-i teek.
• Masinõpe selliste teekidega nagu Figaro tõenäosusliku programmeerimise jaoks ja Apache Spark suuremahuliseks andmetöötluseks.

Anonüümsed funktsioonid

Scala keel toetab anonüümseid funktsioone, mida nimetatakse ka funktsiooniliteraalidKuna Scala on funktsionaalne keel, jagavad arendajad suured probleemid sageli paljudeks väikesteks ülesanneteks ja loovad palju funktsioone. Selle lihtsustamiseks võimaldab Scala funktsioone instantseeritud ilma nimetaSaate need määrata otse muutujatele või definitsioonidele, kasutades def, nagu on näidatud järgmises Scala näites:

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

Seejärel saate neid parameetrite edastamise teel kasutada nagu tavalisi funktsioone:

multiplyByTwo(3)
//6

multiplyByThree(4)
//12

Need meetodid on käepärased, kui soovite puhast ja kokkuvõtlikku koodi. Anonüümsed funktsioonid on kasulikud väikeste meetodite defineerimisel, mis ei vaja oma põhiosas palju koodi. Need on väga lihtsad ja nende loomine ei vaja erilisi tseremooniaid.

Need meetodid ei ole piiratud argumentidega funktsioonidega ja neid saab kasutada argumente mittevõtvate meetodite eksemplaride loomiseks.

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

Enamikku neist anonüümsetest funktsioonidest kasutatakse koodi teistes osades, kus on vaja kiirfunktsiooni. Sel põhjusel nimetatakse neid ka kui tekstisisesed funktsioonidAnonüümsete funktsioonide kasutamine on levinud muster, mis ilmneb kogu kollektsiooniteegis kollektsiooni üle kiirtoimingute tegemiseks.

Näiteks kasutab filtermeetod reafunktsiooni, et luua uus kollektsioon, mis sisaldab ainult anonüümses funktsioonis määratletud kriteeriumidele vastavaid elemente.

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)

Siin kontrollivad anonüümsed funktsioonid, kas loendi väärtus on paaritu või paaritu ning tagastavad sobiva väärtuse.

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

Scalas on võimalik kasutada ka metamärke, kui anonüümse funktsiooni parameetrit ei nimetata. Näiteks:

var timesTwo = (_:Int) * 2

timesTwo(5)
//10

Sellisel juhul ei panda parameetrile nime. Selle tähistamiseks kasutatakse alakriipsu.

Laisk hindamine

Enamik keeli hindab muutujaid ja funktsiooni parameetreid järjestikku, üksteise järel. Scalas on märksõna lazy aitab toime tulla väärtustega, mida te ei soovi enne viitamist hinnata.

Laisaks märgitud muutujat ei hinnata seal, kus see on defineeritud, mida tuntakse ka innukana hindamisena. See hinnatakse alles siis, kui sellele koodis hiljem viidatakse.

See võib olla abiks, kui väärtuse hindamine oleks kulukas arvutus. Kui väärtust pole alati vaja, säästate end kalli arvutuse käivitamisest, mis võib tarkvara aeglustada, muutes muutuja laisaks.

lazy val myExpensiveValue = expensiveComputation

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

See pole laisade muutujate ainus kasutusjuhtum. Need aitavad ka koodis ringsõltuvustega toime tulla.

Kui sätete lipp on „väär”, ei pea te funktsiooni „myExpensiveValue” kasutama, mis säästab teid kallite arvutuste tegemisest. See aitab tagada kasutajatele sujuva kogemuse, kuna ressursse ei raisata väärtustele, mida kunagi ei loeta.

Laiskus aitab ka funktsiooniargumentide puhul, kus argumente kasutatakse ainult siis, kui neile funktsiooni sees viidatakse. Seda kontseptsiooni nimetatakse nimepõhisteks parameetriteks.

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

Paljud programmeerimiskeeled kasutavad argumentide hindamiseks väärtuspõhist lähenemist (call-by-value). Funktsiooni call-by-name kaudu edastatud parameetrit hinnatakse ainult siis, kui seda funktsiooni kehas vaja on. Kui väärtus on hinnatud, salvestatakse see ja seda saab hiljem uuesti kasutada ilma uuesti hindamiseta – seda kontseptsiooni nimetatakse meeldejätmiseks.

Tüüp Järeldus

Scalas ei pea iga loodava muutuja tüüpe deklareerima, kuna Scala kompilaator suudab tüübid tuletada avaldise paremast poolest. See võimaldab koodil olla kokkuvõtlikum ja vabastab teid mallide kirjutamisest, kus eeldatav tüüp on ilmselge.

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

Kõrgema järgu funktsioon

Kõrgema järgu funktsioon on funktsioon, mis saab argumentidena võtta funktsioone ja tagastada funktsiooni tagastustüübina. Scalas peetakse funktsioone esmaklassilisteks kodanikeks. Funktsioonide selline kasutamine võimaldab teil olla väga paindlik programmide loomisel. Saate funktsioone dünaamiliselt luua ja funktsionaalsust dünaamiliselt teistele funktsioonidele edastada.

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

Ülaltoodud funktsioonis annate sisse Int ja funktsioon, mis võtab Int ja tagastab IntSaate edastada mis tahes selle signatuuriga funktsiooni. Signatuuri all peame silmas funktsiooni sisendit ja väljundit. Signatuur Int => Int tähendab, et funktsioon võtab sisendiks täisarvu (Int) ja tagastab väljundiks täisarvu (Int).

Allkiri () => Int tähendab, et funktsioon ei võta sisendiks midagi ja tagastab väljundina tervikarvu (Int). Sellise funktsiooni näide on see, mis genereerib juhusliku tervikarvu (Int).

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

Ülaltoodud funktsioonil on signatuur () => Int.

Funktsioonil võib olla ka signatuur () => UnitSee tähendab, et funktsioon ei võta midagi vastu ega tagasta tüüpi. Selle asemel võib funktsioon muuta mingit olekut või sooritada ettemääratud toimingu.

Selliseid meetodeid ei soovitata, kuna need võivad toimida musta kastina, mis mõjutab süsteemi tundmatul viisil. Neid on ka raskem testida. Selgesõnaliste sisend- ja väljundtüüpide olemasolu võimaldab teil arutleda oma funktsiooni toimimise üle.

Kõrgema järgu funktsioon saab samuti funktsiooni tagastada. Näiteks võiksite luua meetodi, mis tagastab astmefunktsiooni, mis võtab arvu ja rakendab sellele astendust.

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

Ülaltoodud funktsioon võtab täisarvu (Int). Selle tagastustüüp on anonüümne funktsioon, mis võtab täisarvu (Int). x ja kasutab seda astmefunktsiooni argumendina.

Karrimine

Scalas saab kahte argumenti kasutava funktsiooni teisendada üheks funktsiooniks, mis võtab korraga ainult ühe argumendi. Ühe argumendi sisestamisel rakendatakse seda osaliselt ja tulemuseks on funktsioon, mis võtab ülejäänud argumendi kõne lõpetamiseks. Currying võimaldab funktsioone luua mõnede argumentide osalise lisamise teel.

See on kasulik funktsioonide dünaamiliseks loomiseks enne, kui teil on olemas täielik argumentide komplekt.

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

Kui vajate funktsiooni, mis korrutab kindla arvuga, ei pea te looma uut korrutusmeetodit. Saate rakendada ühe argumendi karrifunktsioonile ja tulemust uuesti kasutada:

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

var multiplyByFive = multiplyTwoNumbers(5) _

multiplyByFive(4)

//returns 20

Mustri sobitamine

Scalal on võimas sisseehitatud mehhanism, mis aitab kontrollida, kas muutuja vastab teatud kriteeriumidele, sarnaselt lülitilausega Java või if/else lausete ahel. Keel toetab mustrite sobitamist, mida saab kasutada muutuja tüübi kontrollimiseks. Mustrite sobitamine Scalas on võimas ja suudab destruktureerida komponente, millel on unapply meetod, et saada olulised väljad otse sobitatavast muutujast.

Scala mustrite sobitamine pakub ka meeldivamat süntaksit kui lülituslause.

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

Sa võrdled muutujat valikute komplektiga. Kui muutuja vastab kriteeriumidele, siis paksu noole (=>) paremal küljel olev avaldis väärtustub ja tagastab vaste tulemusena.

Alakriips püüab kinni juhtumeid, millele koodis vastet ei leita, peegeldades vaikimisi juhtumi käitumist lülituslauses.

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

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

Ülaltoodud koodis saate tuvastada tüübi myItem muutuja ja selle põhjal hargneda konkreetse koodini.

Mustri sobitamine kontrollib, kas muutuja vastab igale juhtumile järjekorras.

Alakriips toimib kohatäitena, mis vastab mis tahes tingimusele, millele teised case-laused ei vasta. Te võtate muutuja myItem ja helistage match meetod.

• Kontrollige, kas myItem is true ja käivitage loogika paksu noole “=>” paremal küljel.
• Kasutage alakriipsu, et leida vaste kõigele, mis ei vasta ühelegi koodis määratletud juhtumilausele.

Juhtumiklasside abil saate klassi destruktureerida näidiseks (ex).tract-väljad objekti sees.

Kasutades sealed märksõna klasside defineerimiseks, saad eelise, et kompilaator kontrollib põhjalikult juhtumeid, mida proovid sobitada, ja hoiatab sind, kui unustad mõne käsitleda.

Muutmatus

Scala funktsioonide abil on võimalik luua väärtusi, mida teised funktsioonid muuta ei saa. val märksõna. See saavutatakse Java kasutades final märksõna. Scalas kasutate a val muutuja loomisel selle asemel var, mis on muudetavate muutujate alternatiiv.

Muutuja, mis on defineeritud, kasutades val märksõna on kirjutuskaitstud, samas kui see on defineeritud kui var saab hiljem lugeda ja muuta teiste funktsioonide või kasutaja poolt koodis.

var changeableVariable = 8

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

println(changeableVariable)
//10

val myNumber = 7

myNumber = 4

//this will not compile

Püüan väärtust määrata myNumber pärast selle kuulutamist val viskab kompileerimisaja vea: „reassignment to val.”

Miks kasutada muutumatust?

Muutmatus aitab vältida koodi ja teiste programmeerijate poolt ootamatuid väärtuste muutmisi, mis tooksid kaasa ettearvamatuid tulemusi. Kui väärtuse tarbijad peavad seda muutma, saavad nad selle asemel teha koopia. Nii välditakse vigu, mis tekivad mitme osaleja sama muutuja muutmisel.

Klassid ja objektid

Objektid on reaalse maailma üksused ja klass on mall, mis defineerib objekte. Klassidel on nii olek kui ka käitumine. Olekud on kas väärtused või muutujad. Käitumine on Scala meetodid.

Järgmises osas näidatakse, kuidas klassi defineerida, selle eksemplari luua ja Scalas kasutada.

Siin on klass nimega Rectangle, millel on kaks väärtust ja kaks funktsiooni. Võite kasutada ka parameetreid l ja b otse programmis väljadena. Teil on objekt, millel on main-meetod ja mis loob klassile kahe väärtuse.

Näide:

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

Scalas on kõik väljad ja meetodid vaikimisi avalikud. Oluline on kasutada override sest toString on Scalas juba iga objekti jaoks defineeritud.

Pärisosa

Scalal on mitu pärimistüüpi (ühe-, mitmetasandiline, mitmekordne, hierarhiline ja hübriidne), millel on palju ühist traditsiooniliste vormidega, mida leidub JavaPärida saab nii klassidest kui ka tunnustest. Ühe klassi liikmed päritakse teise klassi märksõna abil. extendsSee võimaldab korduvkasutatavust.

Pärida on võimalik ühest või mitmest klassist. Samuti on võimalik pärida alamklassidest, millel endil on oma ülemklassid, luues protsessi käigus pärimishierarhia.

Allolevas Scala näites on baasklass Circleja tuletatud klass on SphereRingil on väärtus nimega raadius, mis pärineb klassist Sphere. Meetod calcArea on märksõna abil tühistatud override.

Näide:

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

Abstracmine

Scalas saab teha kõhulihaseidtract-meetodid ja liikmeväljad, mis kasutavad abs-itract klassid ja tunnused. Kõhulihaste seestract klasside ja tunnuste abil saate defineerida kõhulihaseidtract väljad ilma neid rakendamata.

Näide:

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

Neid välju rakendavad klassid, mis laiendavad tunnust või abstract klass. Konfliktide loomiseks võite kasutada tunnuseidtracts selle kohta, mida rakendus peaks tegema, ja seejärel need meetodid hiljem rakendada.

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

Nii saate planeerida rakenduse välimust ilma meetodeid rakendamata, näiteksping Sa kujutad ette, kuidas erinevad meetodid välja näevad. See järgib mustrit, mida tuntakse kõhulihaste programmeerimisena.tracpigem meetmetele kui tegelikule rakendamisele.

Klass, millele eelneb abstract märksõna võib sisaldada nii abstract ja mitte-abstract-meetodid. Mitmekordne pärimine aga abs-meetodites ei ole toetatud.tract-tunnid, nii et saate sirutada ainult ühte kõhulihasttract-klass.

Üksikud objektid

Üksikklass on klass, mis luuakse programmis ainult üks kord. See pärineb populaarsest ja kasulikust programmeerimismustrist, mida tuntakse kui „üksikklassi mustrit“. See on kasulik selliste eksemplaride loomiseks, mis on mõeldud pikaajaliseks ja programmis ühiselt ligipääsetavaks kasutamiseks, kus olek on süsteemi sündmuste koordineerimise lahutamatu osa. Sellise klassi loomine Scalas on lihtne, sest Scala pakub lihtsat viisi üksikute klasside loomiseks, kasutades object märksõna.

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

Seejärel saate sellele objektile kogu programmi vältel viidata, garanteerides, et kõik programmi osad näevad samu andmeid, kuna sellest on ainult üks eksemplar.

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

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

Staatiliste liikmete kontseptsiooni Scalas ei eksisteeri, mistõttu kasutatakse üksikobjekte, mis toimivad klassi staatiliste liikmetena.

Kaudsed klassid

Implitsiitsed klassid on versioonis 2.10 lisatud funktsioon ja neid kasutatakse peamiselt olemasolevatele suletud klassidele uue funktsionaalsuse lisamiseks.

. implicit Märksõna tuleks defineerida klassis, objektis või tunnuses. Implitsiitse klassi primaarsel konstruktoril peab olema oma esimeses parameetriloendis täpselt üks argument. See võib sisaldada ka täiendavat implitsiitset parameetriloendit.

Allolevas Scala näites on lisatud uus funktsioon stringi täishäälikute asendamiseks tärniga (*).

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

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

Peate importima implitsiitse klassi klassi, kus te seda kasutate.

import StringUtil.StringEnhancer

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

Objektorienteeritud programmeerimine (OOP) vs. funktsionaalne programmeerimine (FP)

OOP-s konstrueeritakse programme gruppide kaupa.ping andmed ja nende andmetega töötavad funktsioonid omavahel tihedalt seotud üksusteks. Objektid kannavad oma andmeid väljadel ja meetodid opereerivad nendega. Selles programmeerimisstiilis on peamised abstractsioon on andmed, sest loodud meetodid on mõeldud andmetega töötamiseks.

Funktsionaalne programmeerimineTeisest küljest eraldab andmed ja funktsioonid, mis neid töötlevad. See võimaldab arendajatel käsitleda funktsioone kui abstracprogrammide modelleerimisel.

Scala võimaldab funktsionaalset programmeerimist, käsitledes funktsioone esmaklassiliste kodanikena, võimaldades neid edastada väärtustena teistele funktsioonidele ja tagastada samuti väärtustena. Nende kahe paradigma kombinatsioon on teinud Scalast suurepärase valiku keeruka tarkvara loomiseks sellistes tööstusharudes nagu andmeteadus.

Scala olulised raamistikud

Siin on mõned Scala jaoks olulised raamistikud:

• mängima on avatud lähtekoodiga veebirakenduste raamistik, mis kasutab MVC arhitektuurSee ilmus 2007. aastal ja on nüüd Apache litsentsi all ning sai 2013. aastaks GitHubi üheks populaarseimaks raamistikuks. Ettevõtted nagu LinkedIn, WalmartSamsung ja Eero kasutavad seda raamistikku.
• Tõstma on veel üks tasuta veebiraamistik, mis on kirjutatud Scalas ja käivitati 2007. aastal. Foursquare kasutab Lifti raamistikku. See on suure jõudlusega raamistik, millega on kiire luua.
• Acre pakub tööriistakomplekti JVM-il väga samaaegsete, hajutatud ja vastupidavate sõnumipõhiste rakenduste loomiseks.
• Kassid on raamatukogu, mis pakub kõhulihaste treeninguidtracfunktsionaalse programmeerimise tingimused.
• Spark on ühtne analüüsimootor suuremahuliseks andmetöötluseks, mida kasutatakse laialdaselt suurandmete ja masinõppe töövoogudes.

Samaaegsuse tugi

• Scala väärtused on vaikimisi muutmatud, mis muudab selle samaaegsete keskkondade jaoks väga kohanemisvõimeliseks.
• Scalal on palju funktsioone, mis muudavad selle ideaalseks samaaegsete rakenduste jaoks.
• Futuurid ja lubadused muudavad andmete asünkroonse töötlemise lihtsamaks, toetades sellega paralleelsust.
• Akka on tööriistakomplekt, mis kasutab Actorsi samaaegsuse mudelit. Actorid tegutsevad siis, kui nad saavad sõnumeid.
• Samaaegsus, kasutades lõime alates Java on toetatud ka Scalas.
• Vootöötlus on veel üks suurepärane funktsioon, mis võimaldab andmete pidevat ja reaalajas töötlemist.

Scalal on mõned parimad samaaegsusteegid Java ökosüsteem:

• Pärit Java niidid.
• Kiud raamatukogudest nagu Vertx.
• ZIO, teek, mis sisaldab primitiivid samaaegsuse ja asünkroonse arvutamise hõlbustamiseks.
• Tarkvara tehingumälu (STM) tehingute jaoks.
• Future, mis on Scala keelde sisse ehitatud.

Java vs Scala

Siin on peamine erinevused Java ja Scala.

KKK