Grundläggande syntax och typer
Förstå Scalas grundläggande syntax, variabeldeklarationer (val/var), vanliga datatyper och grundläggande operatorer.
Grundläggande syntax och typer är en gratis lektion i Scala för backendutveckling och funktionell programmering på CoddyKit. Detta är lektion 2 av 3. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Scala för backendutveckling och funktionell programmering, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 3 lektioner.
Scalas rena syntax
Välkommen till Scalas grundläggande syntax! Scala är utformat för att vara koncist och uttrycksfullt, vilket ofta gör att du kan åstadkomma mer med mindre kod.
Till skillnad från vissa språk är semikolon vanligtvis valfria i slutet av en rad om den bara innehåller en sats. Det bidrar till att hålla koden ren.
Uttryck är centrala
I Scala är nästan allt ett uttryck, vilket innebär att det utvärderas till ett värde. Det är ett kraftfullt koncept som gör koden mer funktionell och förutsägbar.
Även en enkel beräkning eller ett villkorsblock kan returnera ett värde.
Försök köra det här exemplet:
object Main {
def main(args: Array[String]): Unit = {
val x = 5 + 3
println(s"The value of x is: $x")
val message = if (x > 7) "Greater than 7" else "Not greater than 7"
println(message)
}
}`val`: Oföränderliga värden
När du deklarerar en variabel med val skapar du ett oföränderligt värde. Det innebär att värdet inte kan ändras när det väl har tilldelats.
Oföränderlighet är en grundpelare inom funktionell programmering och bidrar till att förhindra oväntade sidoeffekter, vilket gör koden säkrare och enklare att förstå.
Prova själv:
object Main {
def main(args: Array[String]): Unit = {
val greeting = "Hello, Coddy!"
println(greeting)
// greeting = "New message" // This would cause a compile error!
}
}`var`: Föränderliga variabler
Ibland behöver du en variabel vars värde kan ändras. Därför erbjuder Scala var för föränderliga variabler.
Även om det kan vara användbart är det god praxis i Scala att föredra val framför var när det är möjligt, för att främja oföränderlighet och en funktionell stil.
Se hur `var` fungerar:
object Main {
def main(args: Array[String]): Unit = {
var counter = 0
println(s"Initial counter: $counter")
counter = counter + 1
println(s"New counter: $counter")
}
}Tal: Int, Long, Double
Scala har stöd för vanliga numeriska typer. Kompilatorn härleder ofta typen, men du kan också ange den.
Int: För heltal (t.ex.10)Long: För större heltal (suffixetL, t.ex.10000000000L)Double: För flyttal (decimaltal, t.ex.3.14)
Här är ett exempel:
object Main {
def main(args: Array[String]): Unit = {
val anInt = 42
val aLong = 1234567890123L
val aDouble = 3.14159
println(s"Int: $anInt")
println(s"Long: $aLong")
println(s"Double: $aDouble")
}
}Typerna Boolean och Char
Utöver tal har Scala typer för sanningsvärden och enskilda tecken:
Boolean: Representerar sanningsvärden, antingentrueellerfalse.Char: Lagrar ett enskilt tecken inom enkla citattecken (t.ex.'A').
Dessa är grundläggande för logik och textbehandling.
Exempel:
object Main {
def main(args: Array[String]): Unit = {
val isActive = true
val initial = 'C'
println(s"Is active? $isActive")
println(s"Initial character: $initial")
}
}Strängar och text
Typen String används för teckensekvenser, alltså text. Strängar är oföränderliga i Scala, precis som i Java.
En mycket användbar funktion är stränginterpolering, som låter dig bädda in uttryck direkt i strängliteraler med prefixet s och $ för variabler.
Ta en titt:
object Main {
def main(args: Array[String]): Unit = {
val name = "Coddy"
val age = 3
val greeting = s"Hello, my name is $name and I am $age years old."
println(greeting)
val mathResult = s"Two plus two is ${2 + 2}"
println(mathResult)
}
}Grundläggande aritmetiska operatorer
Scala har standardoperatorer för aritmetiska beräkningar med tal:
+(Addition)-(Subtraktion)*(Multiplikation)/(Division)%(Modulo – resten vid division)
Operatorerna fungerar som du förväntar dig och returnerar ett nytt numeriskt värde.
Nu räknar vi lite:
object Main {
def main(args: Array[String]): Unit = {
val a = 10
val b = 3
println(s"Addition: ${a + b}")
println(s"Subtraction: ${a - b}")
println(s"Multiplication: ${a * b}")
println(s"Division: ${a / b} (integer division)")
println(s"Modulo: ${a % b}")
val c = 10.0
val d = 3.0
println(s"Float Division: ${c / d}")
}
}Jämförelseoperatorer
Jämförelseoperatorer används för att jämföra två värden och returnerar alltid en Boolean (true eller false).
==(Lika med)!=(Inte lika med)<(Mindre än)>(Större än)<=(Mindre än eller lika med)>=(Större än eller lika med)
De är avgörande för styrflöde och beslutsfattande.
object Main {
def main(args: Array[String]): Unit = {
val x = 10
val y = 5
println(s"x == y: ${x == y}")
println(s"x != y: ${x != y}")
println(s"x > y: ${x > y}")
println(s"x <= y: ${x <= y}")
}
}Snabbkontroll: variabler och operatorer
Betrakta följande Scala-kodsnutt:
object Main {
def main(args: Array[String]): Unit = {
val num1 = 7
var num2 = 3
num2 = num1 * 2
val finalResult = num1 + num2 - 5
println(finalResult)
}
}Sammanfattning: syntax och typer
Bra jobbat! I den här lektionen har du lärt dig grunderna i Scalas syntax, bland annat hur uttryck används och att semikolon är valfria.
Vi gick igenom hur variabler deklareras med val för oföränderliga värden och var för föränderliga. Du blev också bekant med vanliga datatyper som Int, Long, Double, Boolean, Char och String, inklusive praktisk stränginterpolering.
Slutligen övade du på att använda grundläggande aritmetiska operatorer och jämförelseoperatorer för beräkningar och logiska kontroller. Fortsätt öva på dessa grunder eftersom de är byggstenarna i mer komplexa Scala-program!
Lär dig Scala med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 39
- Lektioner
- 143
Vanliga frågor
Är lektionen ”Grundläggande syntax och typer” gratis?
Ja – hela texten till ”Grundläggande syntax och typer” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Scala för backendutveckling och funktionell programmering, kan Ni uppgradera till CoddyKit PRO. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 3 lektioner.
Vad lär jag mig i ”Grundläggande syntax och typer”?
Förstå Scalas grundläggande syntax, variabeldeklarationer (val/var), vanliga datatyper och grundläggande operatorer. Ni övar på Scala för backendutveckling och funktionell programmering med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Scala för backendutveckling och funktionell programmering?
Du behöver inga förkunskaper. Utbildningen i Scala för backendutveckling och funktionell programmering på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 3.
Hur lång tid tar lektionen ”Grundläggande syntax och typer”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Scala för backendutveckling och funktionell programmering-lektionen?
Ja. Varje Scala för backendutveckling och funktionell programmering-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Kom igång med Scala
- Grundläggande syntax och typer
- Kontrollstrukturer och funktioner