Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian · Pelajaran

Ketidakbolehubahan dan Kesan Sampingan

Fahami kepentingan ketidakbolehubahan dalam pengaturcaraan fungsian dan cara mengurus kesan sampingan dengan berkesan.

Pelajaran 3 daripada 311 langkah

Ketidakbolehubahan dan Kesan Sampingan ialah pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian percuma di CoddyKit. Ini ialah pelajaran 3 daripada 3. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 3 pelajaran.

Tidak Berubah Mengikut Reka Bentuk

Selamat datang ke pelajaran kami tentang Ketidakbolehubahan dan Kesan Sampingan! Ini ialah konsep teras dalam pengaturcaraan berfungsi (FP) yang membantu kita menulis kod yang lebih kemas dan lebih mudah diramal.

Dalam FP, kita lebih suka bekerja dengan data tidak berubah. Ini bermakna selepas sekeping data dicipta, data itu tidak boleh diubah. Anggaplah ia seperti sekeping gambar – anda boleh melihatnya, tetapi tidak boleh mengubah detik asal yang dirakamnya.

val berbanding var dalam Scala

Scala memudahkan pengisytiharan nilai tidak berubah menggunakan kata kunci val. Ini ialah rujukan malar yang tidak boleh ditetapkan semula selepas takrifan awalnya. Untuk pemboleh ubah yang boleh berubah, anda menggunakan var.

Mari lihat perbezaannya:

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 Ketidakbolehubahan Penting

Ketidakbolehubahan memberikan beberapa manfaat penting kepada kod anda, khususnya dalam sistem serentak dan kompleks:

Kebolehramalan: Anda sentiasa tahu bahawa sesuatu nilai tidak akan berubah tanpa diduga.
Keselamatan Keserentakan: Berbilang bahagian program anda boleh membaca data yang sama tanpa bimbang bahagian lain mengubahnya. Tiada kunci kompleks diperlukan!
Nyahpepijat yang Lebih Mudah: Mengesan pepijat menjadi lebih mudah kerana anda tidak perlu bimbang tentang keadaan yang berubah dari semasa ke semasa.

Koleksi Tidak Berubah

Pustaka standard Scala sangat mengutamakan koleksi tidak berubah secara lalai. Apabila anda 'mengubah suai' koleksi tidak berubah, anda sebenarnya mendapat koleksi baharu dengan perubahan tersebut, manakala koleksi asal kekal tidak disentuh.

Berikut ialah contoh menggunakan List tidak berubah:

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 Kesan Sampingan

Berbeza dengan ketidakbolehubahan, kesan sampingan berlaku apabila fungsi atau ungkapan melakukan sesuatu selain sekadar mengembalikan nilai. Ia berinteraksi dengan 'dunia luar' atau mengubah keadaan yang boleh berubah.

Kesan sampingan yang biasa termasuk:

Mengubah suai pemboleh ubah global atau objek yang boleh berubah.
Mencetak ke konsol (I/O).
Menulis ke fail atau pangkalan data.
Mengubah jam sistem.

Masalah Kesan Sampingan

Walaupun kesan sampingan kadangkala diperlukan, dalam pengaturcaraan berfungsi, kita berusaha untuk meminimumkan dan mengasingkannya. Mengapa?

Lebih Sukar untuk Difahami: Output sesuatu fungsi boleh bergantung pada keadaan luaran, lalu menjadikannya sukar diramal.
Sukar untuk Diuji: Ujian perlu menyediakan dan membersihkan keadaan luaran.
Isu Keserentakan: Berbilang utas yang melakukan kesan sampingan boleh menyebabkan keadaan perlumbaan dan pepijat.

Mengenal Pasti Kesan Sampingan dalam Kod

Mari lihat contoh Scala. Satu fungsi mempunyai kesan sampingan, manakala satu lagi tidak. Bolehkah anda mengenal pasti perbezaannya?

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 Tulen: Cita-cita FP

Matlamat utama dalam FP ialah menulis fungsi tulen. Fungsi tulen mempunyai dua ciri utama:

Ia sentiasa menghasilkan output yang sama untuk input yang sama (deterministik).
Ia tidak menyebabkan kesan sampingan (tidak mengubah apa-apa di luar skopnya).

Fungsi pureAdd dalam contoh sebelumnya ialah fungsi tulen!

Mengurus Kesan Sampingan

Memandangkan sesetengah kesan sampingan tidak dapat dielakkan (seperti mencetak hasil atau menyimpan data), pendekatan FP adalah untuk:

Mengasingkannya: Asingkan fungsi yang mempunyai kesan sampingan daripada fungsi tulen.
Menolaknya ke bahagian tepi: Lakukan I/O pada awal atau akhir program anda, atau dalam bahagian 'berkesan' yang khusus.
Menggunakan binaan FP: Pustaka sering menyediakan jenis (seperti IO atau Task) untuk mewakili dan mengurus kesan secara jelas.

Uji Pemahaman Anda

Berdasarkan perkara yang telah anda pelajari, pernyataan manakah tentang ketidakbolehubahan dan kesan sampingan dalam pengaturcaraan berfungsi yang TRUE?

Jawab dalam pelajaran interaktif

Imbas Kembali: Ketidakbolehubahan dan Kesan

Syabas! Dalam pelajaran ini, kita meneroka konsep penting ketidakbolehubahan dan kesan sampingan dalam pengaturcaraan berfungsi.

Kita melihat bagaimana val menggalakkan ketidakbolehubahan dalam Scala, lalu menghasilkan kod yang lebih mudah diramal dan selamat untuk keserentakan.
Kita mentakrifkan kesan sampingan sebagai interaksi di luar nilai yang dikembalikan oleh fungsi dan memahami sebab kesan ini boleh merumitkan kod.
Akhir sekali, kita mempelajari fungsi tulen sebagai cita-cita FP, yang bersifat deterministik dan bebas daripada kesan sampingan, serta strategi untuk mengurus kesan sampingan yang diperlukan.

Menguasai konsep-konsep ini penting untuk menulis aplikasi Scala berfungsi yang teguh dan elegan!

Percuma untuk bermula

Pelajari Scala dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 39
Pelajaran: 143

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Ketidakbolehubahan dan Kesan Sampingan” percuma?

Ya — teks penuh “Ketidakbolehubahan dan Kesan Sampingan” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, tingkat taraf kepada CoddyKit PRO. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 3 pelajaran.

Apakah yang akan saya pelajari dalam “Ketidakbolehubahan dan Kesan Sampingan”?

Fahami kepentingan ketidakbolehubahan dalam pengaturcaraan fungsian dan cara mengurus kesan sampingan dengan berkesan. Anda berlatih Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 3.

Berapa lamakah pelajaran “Ketidakbolehubahan dan Kesan Sampingan” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian ini?

Ya. Setiap pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian