val-mutable versus var-immutable di Scala

Apakah ada pedoman di Scala tentang kapan menggunakan val dengan koleksi yang bisa diubah versus menggunakan var dengan koleksi yang tidak bisa diubah? Atau haruskah Anda benar-benar mengincar val dengan koleksi yang tidak dapat diubah?

Fakta bahwa ada kedua jenis koleksi itu memberi saya banyak pilihan, dan seringkali saya tidak tahu bagaimana cara menentukan pilihan itu.

Pertanyaan yang cukup umum, yang ini. Hal yang sulit adalah menemukan duplikatnya.

Anda harus berusaha untuk transparansi referensial . Artinya, jika saya memiliki ekspresi "e", saya bisa membuat val x = e, dan menggantinya edengan x. Ini adalah properti yang dapat dirusak oleh mutabilitas. Kapan pun Anda perlu membuat keputusan desain, maksimalkan untuk transparansi referensial.

Secara praktis, metode-lokal varadalah yang paling aman varyang ada, karena tidak luput dari metode tersebut. Jika metodenya pendek, bahkan lebih baik. Jika tidak, coba kurangi dengan mengekstrak metode lain.

Di sisi lain, koleksi yang bisa berubah berpotensi untuk melarikan diri, meskipun tidak. Saat mengubah kode, Anda mungkin ingin meneruskannya ke metode lain, atau mengembalikannya. Itu adalah jenis hal yang merusak transparansi referensial.

Pada suatu objek (bidang), hal yang hampir sama terjadi, tetapi dengan konsekuensi yang lebih mengerikan. Bagaimanapun, objek akan memiliki status dan, oleh karena itu, merusak transparansi referensial. Tetapi memiliki koleksi yang bisa berubah berarti bahkan objek itu sendiri mungkin kehilangan kendali atas siapa yang mengubahnya.

Jika Anda bekerja dengan koleksi yang tidak dapat diubah dan Anda perlu "memodifikasinya", misalnya, menambahkan elemen ke dalamnya dalam satu putaran, Anda harus menggunakan vars karena Anda perlu menyimpan koleksi yang dihasilkan di suatu tempat. Jika Anda hanya membaca dari koleksi yang tidak dapat diubah, gunakan vals.

Secara umum, pastikan Anda tidak membingungkan referensi dan objek. vals adalah referensi tetap (penunjuk konstan di C). Artinya, saat Anda menggunakan val x = new MutableFoo(), Anda akan dapat mengubah objek yang xdituju, tetapi Anda tidak akan dapat mengubah ke objek mana x . Kebalikannya berlaku jika Anda menggunakan var x = new ImmutableFoo(). Mengambil saran awal saya: jika Anda tidak perlu mengubah ke objek mana yang menjadi titik referensi, gunakan vals.

Cara terbaik untuk menjawabnya adalah dengan sebuah contoh. Misalkan kita memiliki beberapa proses yang hanya mengumpulkan angka karena suatu alasan. Kami ingin mencatat nomor ini, dan akan mengirim koleksi ke proses lain untuk melakukannya.

Tentu saja, kami masih mengumpulkan nomor setelah kami mengirimkan koleksi tersebut ke logger. Dan katakanlah ada beberapa overhead dalam proses logging yang menunda logging sebenarnya. Semoga Anda bisa melihat ke mana arahnya.

Jika kita menyimpan koleksi ini dalam bentuk yang bisa berubah val, (bisa berubah karena kita terus menambahkannya), ini berarti bahwa proses yang melakukan pencatatan akan melihat objek yang sama yang masih diperbarui oleh proses pengumpulan kita. Koleksi itu dapat diperbarui kapan saja, jadi ketika waktunya untuk masuk, kami mungkin tidak benar-benar mencatat koleksi yang kami kirim.

Jika kami menggunakan yang tidak dapat diubah var, kami mengirimkan struktur data yang tidak dapat diubah ke pencatat. Ketika kita menambahkan angka lebih untuk koleksi kami, kami akan mengganti kita vardengan struktur data berubah baru . Ini tidak berarti koleksi yang dikirim ke logger diganti! Itu masih merujuk pada koleksi yang dikirimnya. Jadi logger kami memang akan mencatat koleksi yang diterimanya.

Saya pikir contoh dalam posting blog ini akan menjelaskan lebih banyak, karena pertanyaan tentang kombo mana yang akan digunakan menjadi lebih penting dalam skenario konkurensi: pentingnya kekekalan untuk konkurensi . Dan sementara kita melakukannya, perhatikan penggunaan yang lebih disukai dari sinkronisasi vs @volatile vs sesuatu seperti AtomicReference: tiga alat

var immutable vs. val mutable

Selain banyak jawaban bagus untuk pertanyaan ini. Berikut adalah contoh sederhana, yang menggambarkan potensi bahaya val mutable:

Objek yang dapat berubah dapat dimodifikasi di dalam metode, yang menjadikannya sebagai parameter, sementara penugasan ulang tidak diperbolehkan.

import scala.collection.mutable.ArrayBuffer

object MyObject {
    def main(args: Array[String]) {

        val a = ArrayBuffer(1,2,3,4)
        silly(a)
        println(a) // a has been modified here
    }

    def silly(a: ArrayBuffer[Int]): Unit = {
        a += 10
        println(s"length: ${a.length}")
    }
}

Hasil:

length: 5
ArrayBuffer(1, 2, 3, 4, 10)

Sesuatu seperti ini tidak dapat terjadi dengan var immutable, karena penugasan ulang tidak diperbolehkan:

object MyObject {
    def main(args: Array[String]) {
        var v = Vector(1,2,3,4)
        silly(v)
        println(v)
    }

    def silly(v: Vector[Int]): Unit = {
        v = v :+ 10 // This line is not valid
        println(s"length of v: ${v.length}")
    }
}

Hasil dalam:

error: reassignment to val

Karena parameter fungsi diperlakukan seperti valpenugasan ulang ini tidak diperbolehkan.