Podstawowa składnia i typy
Poznaj podstawową składnię Scali, deklarowanie zmiennych (val/var), popularne typy danych i podstawowe operatory.
Podstawowa składnia i typy to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 2 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Scala for Backend Engineering & Functional Programming, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Scala for Backend Engineering & Functional Programming zawiera 3 lekcji w sumie.
Przejrzysta składnia Scali
Witamy w podstawach składni Scali! Scala została zaprojektowana jako język zwięzły i wyrazisty, dzięki czemu często pozwala osiągnąć więcej za pomocą mniejszej ilości kodu.
W przeciwieństwie do niektórych języków średniki na końcu wiersza są zwykle opcjonalne, jeśli znajduje się w nim tylko jedna instrukcja. Pomaga to zachować przejrzystość kodu.
Wyrażenia mają kluczowe znaczenie
W Scali niemal wszystko jest wyrażeniem, co oznacza, że oblicza się do wartości. To potężna koncepcja, która sprawia, że kod jest bardziej funkcyjny i przewidywalny.
Nawet proste obliczenie lub blok warunkowy może zwracać wartość.
Spróbuj uruchomić ten przykład:
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`: wartości niemutowalne
Gdy deklarujesz zmienną za pomocą val, tworzysz wartość niemutowalną. Oznacza to, że po przypisaniu jej wartości nie można już zmienić.
Niemutowalność jest podstawą programowania funkcyjnego i pomaga zapobiegać nieoczekiwanym efektom ubocznym, dzięki czemu kod jest bezpieczniejszy i łatwiejszy do zrozumienia.
Wypróbuj:
object Main {
def main(args: Array[String]): Unit = {
val greeting = "Hello, Coddy!"
println(greeting)
// greeting = "New message" // This would cause a compile error!
}
}`var`: zmienne mutowalne
Czasami potrzebujesz zmiennej, której wartość może się zmieniać. W tym celu Scala udostępnia var do tworzenia zmiennych mutowalnych.
Choć jest to przydatne, dobrą praktyką w Scali jest wybieranie val zamiast var, gdy tylko jest to możliwe, aby stosować niemutowalność i styl funkcyjny.
Zobacz, jak działa `var`:
object Main {
def main(args: Array[String]): Unit = {
var counter = 0
println(s"Initial counter: $counter")
counter = counter + 1
println(s"New counter: $counter")
}
}Liczby: Int, Long, Double
Scala obsługuje typowe typy liczbowe. Kompilator często wywnioskuje typ automatycznie, ale można też określić go samodzielnie.
Int: liczby całkowite (np.10)Long: większe liczby całkowite (sufiksL, np.10000000000L)Double: liczby zmiennoprzecinkowe (ułamki dziesiętne, np.3.14)
Oto przykład:
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")
}
}Typy Boolean i Char
Oprócz liczb Scala ma typy reprezentujące wartości logiczne i pojedyncze znaki:
Boolean: reprezentuje wartości logiczne —truealbofalse.Char: przechowuje pojedynczy znak ujęty w apostrofy (np.'A').
Typy te mają podstawowe znaczenie dla logiki i przetwarzania tekstu.
Przykład:
object Main {
def main(args: Array[String]): Unit = {
val isActive = true
val initial = 'C'
println(s"Is active? $isActive")
println(s"Initial character: $initial")
}
}Ciągi znaków i tekst
Typu String używa się do przechowywania sekwencji znaków, czyli tekstu. Ciągi znaków są w Scali niemutowalne, podobnie jak w Javie.
Jedną z bardzo przydatnych funkcji jest interpolacja ciągów znaków, która pozwala osadzać wyrażenia bezpośrednio w literałach tekstowych za pomocą prefiksu s i symbolu $ dla zmiennych.
Sprawdź to:
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)
}
}Podstawowe operatory arytmetyczne
Scala udostępnia standardowe operatory arytmetyczne do wykonywania obliczeń na liczbach:
+(dodawanie)-(odejmowanie)*(mnożenie)/(dzielenie)%(modulo — reszta z dzielenia)
Operatory te działają zgodnie z oczekiwaniami, zwracając nową wartość liczbową.
Wykonajmy kilka obliczeń:
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}")
}
}Operatory porównania
Operatorów porównania używa się do porównywania dwóch wartości. Zawsze zwracają wartość Boolean (true albo false).
==(równe)!=(różne)<(mniejsze niż)>(większe niż)<=(mniejsze lub równe)>=(większe lub równe)
Są niezbędne do sterowania przepływem programu i podejmowania decyzji.
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}")
}
}Szybki test: zmienne i operatory
Rozważ poniższy fragment kodu Scala:
object Main {
def main(args: Array[String]): Unit = {
val num1 = 7
var num2 = 3
num2 = num1 * 2
val finalResult = num1 + num2 - 5
println(finalResult)
}
}Podsumowanie: składnia i typy
Świetna praca! W tej lekcji poznano podstawy składni Scali, w tym użycie wyrażeń i opcjonalność średników.
Omówiono deklarowanie zmiennych za pomocą val dla wartości niemutowalnych i var dla zmiennych mutowalnych. Poznano również popularne typy danych, takie jak Int, Long, Double, Boolean, Char i String, w tym przydatną interpolację ciągów znaków.
Na koniec przećwiczono używanie podstawowych operatorów arytmetycznych i porównania do wykonywania obliczeń oraz sprawdzania warunków logicznych. Warto nadal ćwiczyć te podstawy, ponieważ stanowią fundament bardziej złożonych programów Scala!
Często zadawane pytania
Czy lekcja „Podstawowa składnia i typy” jest bezpłatna?
Tak — pełny tekst „Podstawowa składnia i typy” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Scala for Backend Engineering & Functional Programming, przejdź na CoddyKit PRO. Kurs Scala for Backend Engineering & Functional Programming zawiera 3 lekcji w sumie.
Co nauczysz się w „Podstawowa składnia i typy”?
Poznaj podstawową składnię Scali, deklarowanie zmiennych (val/var), popularne typy danych i podstawowe operatory. Ćwiczysz Scala for Backend Engineering & Functional Programming z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Scala for Backend Engineering & Functional Programming?
Nie wymagamy żadnego doświadczenia. Scala for Backend Engineering & Functional Programming w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 3.
Ile czasu zajmuje lekcja „Podstawowa składnia i typy”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Scala for Backend Engineering & Functional Programming?
Tak. Każda lekcja Scala for Backend Engineering & Functional Programming zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Pierwsze kroki ze Scalą
- Podstawowa składnia i typy
- Struktury sterujące i funkcje