Scala for Backend Engineering & Functional Programming · Pelajaran

Imutabilitas dan Efek Samping

Pahami pentingnya imutabilitas dalam pemrograman fungsional dan cara mengelola efek samping secara efektif.

Imutabilitas dan Efek Samping adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 3 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.

Tidak Dapat Diubah Berdasarkan Desain

Selamat datang di pelajaran tentang Ketidakdapatubahan dan Efek Samping! Ini adalah konsep inti dalam pemrograman fungsional (FP) yang membantu kita menulis kode yang lebih bersih dan mudah diprediksi.

Dalam FP, kita lebih suka bekerja dengan data yang tidak dapat diubah. Artinya, setelah suatu data dibuat, data tersebut tidak dapat diubah. Bayangkan data itu seperti foto—Anda dapat melihatnya, tetapi tidak dapat mengubah momen asli yang diabadikannya.

val vs. var di Scala

Scala memudahkan Anda mendeklarasikan nilai yang tidak dapat diubah menggunakan kata kunci val. Ini adalah referensi konstan yang tidak dapat ditetapkan ulang setelah definisi awalnya. Untuk variabel yang dapat diubah, Anda menggunakan var.

Mari lihat perbedaannya:

object Main {
  def main(args: Array[String]): Unit = {
    // Immutable value
    val greeting = "Hello"
    // greeting = "Hi" // This would cause a compile error!

    // Mutable variable
    var count = 0
    count = 1 // This is allowed

    println(greeting)
    println(count)
  }
}

Mengapa Ketidakdapatubahan Penting

Ketidakdapatubahan memberikan beberapa manfaat penting pada kode Anda, terutama dalam sistem konkuren dan kompleks:

Kemudahan Diprediksi: Anda selalu tahu bahwa suatu nilai tidak akan berubah secara tak terduga.
Keamanan Konkruensi: Beberapa bagian program Anda dapat membaca data yang sama tanpa khawatir bagian lain mengubahnya. Tidak diperlukan kunci yang kompleks!
Penelusuran Kesalahan Lebih Mudah: Menemukan kesalahan menjadi lebih sederhana karena Anda tidak perlu mengkhawatirkan keadaan yang berubah seiring waktu.

Koleksi yang Tidak Dapat Diubah

Pustaka standar Scala secara bawaan sangat mengutamakan koleksi yang tidak dapat diubah. Saat Anda 'mengubah' koleksi yang tidak dapat diubah, sebenarnya Anda mendapatkan koleksi baru yang berisi perubahan tersebut, sementara koleksi asli tetap tidak berubah.

Berikut contoh menggunakan List yang tidak dapat diubah:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3)
    val newNumbers = numbers :+ 4 // Creates a new list

    println(s"Original list: $numbers")
    println(s"New list: $newNumbers")
  }
}

Memahami Efek Samping

Berbeda dari ketidakdapatubahan, efek samping terjadi ketika suatu fungsi atau ekspresi melakukan sesuatu selain sekadar mengembalikan nilai. Fungsi atau ekspresi tersebut berinteraksi dengan 'dunia luar' atau mengubah keadaan yang dapat diubah.

Efek samping yang umum meliputi:

Mengubah variabel global atau objek yang dapat diubah.
Mencetak ke konsol (I/O).
Menulis ke berkas atau basis data.
Mengubah jam sistem.

Masalah dengan Efek Samping

Meskipun efek samping terkadang diperlukan, dalam pemrograman fungsional kita berusaha meminimalkan dan mengisolasinya. Mengapa?

Lebih Sulit Dipahami: Keluaran suatu fungsi dapat bergantung pada keadaan eksternal sehingga sulit diprediksi.
Sulit Diuji: Pengujian perlu menyiapkan dan membersihkan keadaan eksternal.
Masalah Konkruensi: Beberapa utas yang menjalankan efek samping dapat menyebabkan kondisi balapan dan kesalahan.

Mengidentifikasi Efek Samping dalam Kode

Mari kita lihat contoh Scala. Salah satu fungsi memiliki efek samping, sedangkan fungsi lainnya tidak. Dapatkah Anda menemukan perbedaannya?

object Main {
  var total = 0 // A mutable global variable

  // Function with a side effect
  def addAndPrint(x: Int, y: Int): Int = {
    total = x + y // Modifies global state
    println(s"Sum is: $total") // I/O side effect
    total
  }

  // Function without side effects (pure function)
  def pureAdd(x: Int, y: Int): Int = {
    x + y // Only returns a value
  }

  def main(args: Array[String]): Unit = {
    addAndPrint(5, 3)
    println(s"Global total: $total")
    println(s"Pure sum: ${pureAdd(5, 3)}")
  }
}

Fungsi Murni: Cita-Cita FP

Tujuan utama dalam FP adalah menulis fungsi murni. Fungsi murni memiliki dua karakteristik utama:

Fungsi tersebut selalu menghasilkan keluaran yang sama untuk masukan yang sama (deterministik).
Fungsi tersebut tidak menimbulkan efek samping (tidak mengubah apa pun di luar cakupannya).

Fungsi pureAdd pada contoh sebelumnya adalah fungsi murni!

Mengelola Efek Samping

Karena beberapa efek samping tidak dapat dihindari (seperti mencetak hasil atau menyimpan data), pendekatan FP adalah:

Mengisolasinya: Pisahkan fungsi yang memiliki efek samping dari fungsi murni.
Mendorongnya ke bagian tepi: Lakukan I/O di awal atau akhir program, atau di dalam bagian khusus yang 'menghasilkan efek'.
Menggunakan konstruksi FP: Pustaka sering menyediakan jenis (seperti IO atau Task) untuk merepresentasikan dan mengelola efek secara eksplisit.

Periksa Pemahaman Anda

Berdasarkan hal yang telah Anda pelajari, manakah pernyataan berikut tentang ketidakdapatubahan dan efek samping dalam pemrograman fungsional yang TRUE?

Ringkasan: Ketidakdapatubahan & Efek

Bagus! Dalam pelajaran ini, kita telah mempelajari konsep penting ketidakdapatubahan dan efek samping dalam pemrograman fungsional.

Kita melihat bagaimana val mendorong ketidakdapatubahan di Scala, sehingga menghasilkan kode yang lebih mudah diprediksi dan aman dalam konkruensi.
Kita mendefinisikan efek samping sebagai interaksi di luar nilai yang dikembalikan fungsi dan memahami alasan efek samping dapat membuat kode lebih rumit.
Terakhir, kita mempelajari fungsi murni sebagai cita-cita FP, yang bersifat deterministik dan bebas dari efek samping, serta strategi untuk mengelola efek samping yang diperlukan.

Menguasai konsep-konsep ini adalah kunci untuk menulis aplikasi Scala fungsional yang tangguh dan elegan!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Imutabilitas dan Efek Samping” gratis?

Ya — teks lengkap “Imutabilitas dan Efek Samping” 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 “Imutabilitas dan Efek Samping”?

Pahami pentingnya imutabilitas dalam pemrograman fungsional dan cara mengelola efek samping secara efektif. 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 3 dari 3.

Berapa lama pelajaran “Imutabilitas dan Efek Samping” 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