Scala for Backend Engineering & Functional Programming · Pelajaran

Sintaks dan Tipe Dasar

Pahami sintaks dasar Scala, deklarasi variabel (val/var), tipe data umum, dan operator dasar.

Sintaks dan Tipe Dasar adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 2 dari 3. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Scala for Backend Engineering & Functional Programming, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Scala for Backend Engineering & Functional Programming mencakup 3 pelajaran total.

Sintaks Scala yang Bersih

Selamat datang di sintaks dasar Scala! Scala dirancang agar ringkas dan ekspresif, sehingga Anda sering kali dapat menulis lebih sedikit kode untuk mencapai hasil yang lebih banyak.

Berbeda dari beberapa bahasa lain, titik koma biasanya bersifat opsional di akhir baris jika hanya ada satu pernyataan. Hal ini membantu menjaga kode Anda tetap rapi.

Ekspresi Adalah Kunci

Di Scala, hampir semuanya adalah sebuah ekspresi, yang berarti ekspresi tersebut dievaluasi menjadi suatu nilai. Ini adalah konsep yang kuat dan membuat kode Anda lebih fungsional serta mudah diprediksi.

Bahkan perhitungan sederhana atau blok kondisional dapat mengembalikan suatu nilai.

Cobalah menjalankan contoh ini:

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`: Nilai yang Tidak Dapat Diubah

Saat Anda mendeklarasikan variabel menggunakan val, Anda membuat nilai yang tidak dapat diubah. Artinya, setelah diberi nilai, nilainya tidak dapat diubah.

Sifat tidak dapat diubah merupakan dasar penting pemrograman fungsional dan membantu mencegah efek samping yang tidak terduga, sehingga kode Anda lebih aman dan lebih mudah dipahami.

Cobalah:

object Main {
  def main(args: Array[String]): Unit = {
    val greeting = "Hello, Coddy!"
    println(greeting)
    // greeting = "New message" // This would cause a compile error!
  }
}

`var`: Variabel yang Dapat Diubah

Terkadang Anda memerlukan variabel yang nilainya dapat berubah. Untuk itu, Scala menyediakan var bagi variabel yang dapat diubah.

Meskipun berguna, praktik yang baik dalam Scala adalah lebih memilih val daripada var jika memungkinkan, agar Anda menerapkan sifat tidak dapat diubah dan gaya fungsional.

Lihat cara kerja `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")
  }
}

Angka: Int, Long, Double

Scala mendukung tipe numerik yang umum. Kompilator sering kali menyimpulkan tipenya, tetapi Anda juga dapat menentukannya.

Int: Untuk bilangan bulat (misalnya, 10)
Long: Untuk bilangan bulat yang lebih besar (akhiran L, misalnya, 10000000000L)
Double: Untuk bilangan pecahan (desimal, misalnya, 3.14)

Berikut contohnya:

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

Tipe Boolean dan Char

Selain angka, Scala memiliki tipe untuk nilai kebenaran dan karakter tunggal:

Boolean: Merepresentasikan nilai kebenaran, yaitu true atau false.
Char: Menyimpan satu karakter yang diapit tanda petik tunggal (misalnya, 'A').

Tipe-tipe ini merupakan dasar untuk logika dan pemrosesan teks.

Contoh:

object Main {
  def main(args: Array[String]): Unit = {
    val isActive = true
    val initial = 'C'

    println(s"Is active? $isActive")
    println(s"Initial character: $initial")
  }
}

String dan Teks

Tipe String digunakan untuk rangkaian karakter atau teks. String tidak dapat diubah di Scala, sama seperti di Java.

Fitur yang sangat berguna adalah Interpolasi String, yang memungkinkan Anda menyisipkan ekspresi secara langsung ke dalam literal string menggunakan awalan s dan $ untuk variabel.

Perhatikan contoh ini:

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

Operator Aritmetika Dasar

Scala menyediakan operator aritmetika standar untuk melakukan perhitungan dengan angka:

+ (Penjumlahan)
- (Pengurangan)
* (Perkalian)
/ (Pembagian)
% (Modulus - sisa pembagian)

Operator-operator ini bekerja seperti yang Anda harapkan dan mengembalikan nilai numerik baru.

Mari lakukan beberapa perhitungan:

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

Operator Perbandingan

Operator perbandingan digunakan untuk membandingkan dua nilai dan selalu mengembalikan Boolean (true atau false).

== (Sama dengan)
!= (Tidak sama dengan)
< (Kurang dari)
> (Lebih dari)
<= (Kurang dari atau sama dengan)
>= (Lebih dari atau sama dengan)

Operator ini penting untuk alur kendali dan pengambilan keputusan.

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

Pemeriksaan Cepat: Variabel & Operator

Perhatikan potongan kode Scala berikut:

object Main {
  def main(args: Array[String]): Unit = {
    val num1 = 7
    var num2 = 3
    num2 = num1 * 2
    val finalResult = num1 + num2 - 5
    println(finalResult)
  }
}

Ringkasan: Sintaks & Tipe

Kerja bagus! Dalam pelajaran ini, Anda telah mempelajari dasar-dasar sintaks Scala, termasuk penggunaan ekspresi dan sifat titik koma yang opsional.

Kita membahas cara mendeklarasikan variabel menggunakan val untuk nilai yang tidak dapat diubah dan var untuk nilai yang dapat diubah. Anda juga telah mengenal tipe data umum seperti Int, Long, Double, Boolean, Char, dan String, termasuk Interpolasi String yang praktis.

Terakhir, Anda berlatih menggunakan operator aritmetika dan perbandingan dasar untuk melakukan perhitungan serta pemeriksaan logika. Teruslah berlatih menggunakan dasar-dasar ini karena semuanya merupakan fondasi bagi program Scala yang lebih kompleks!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Sintaks dan Tipe Dasar” gratis?

Ya — teks lengkap “Sintaks dan Tipe Dasar” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Scala for Backend Engineering & Functional Programming, upgrade ke CoddyKit PRO. Kursus Scala for Backend Engineering & Functional Programming mencakup 3 pelajaran total.

Apa yang akan aku pelajari di “Sintaks dan Tipe Dasar”?

Pahami sintaks dasar Scala, deklarasi variabel (val/var), tipe data umum, dan operator dasar. Kamu berlatih Scala for Backend Engineering & Functional Programming dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Scala for Backend Engineering & Functional Programming?

Tidak diperlukan pengalaman sebelumnya. Scala for Backend Engineering & Functional Programming di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 3.

Berapa lama pelajaran “Sintaks dan Tipe Dasar” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Scala for Backend Engineering & Functional Programming ini?

Ya. Setiap pelajaran Scala for Backend Engineering & Functional Programming menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Scala for Backend Engineering & Functional Programming