val-мутаційний проти var-незмінний у Scala

Чи є в Scala якісь вказівки щодо того, коли використовувати val із колекцією, що змінюється, порівняно з var із незмінною колекцією? Або вам справді слід прагнути валь з незмінною колекцією?

Той факт, що є обидва типи колекції, дає мені багато вибору, і часто я не знаю, як зробити цей вибір.

Досить поширене питання, це. Найважче - знайти дублікати.

Вам слід прагнути до прозорості . Що це означає, що, якщо у мене є вираз «е», я міг би зробити val x = e, і замінити eз x. Це властивість, яка порушує незмінність. Щоразу, коли вам потрібно прийняти дизайнерське рішення, максимізуйте для прозорості референс.

Щодо практичного питання, метод локальних varє найбезпечнішим із існуючих var, оскільки він не уникає методу. Якщо метод короткий, ще краще. Якщо це не так, спробуйте зменшити його, витягнувши інші методи.

З іншого боку, колекція , що змінюється, має можливість вирватися, навіть якщо її немає. Змінюючи код, ви можете потім передати його іншим методам або повернути його. Це та річ, яка порушує прозору прозорість.

З об’єктом (полем) відбувається майже все те саме, але з більш тяжкими наслідками. У будь-якому випадку об'єкт матиме стан і, отже, порушує прозорість. Але мати колекцію, що змінюється, означає, що навіть сам об'єкт може втратити контроль над тим, хто його змінює.

Якщо ви працюєте з незмінними колекціями і вам потрібно "модифікувати" їх, наприклад, додавати до них елементи в циклі, тоді вам доведеться використовувати vars, оскільки вам потрібно десь зберігати отриману колекцію. Якщо ви читаєте лише з незмінних колекцій, тоді використовуйте vals.

Загалом, переконайтеся, що ви не плутаєте посилання та об’єкти. vals - незмінні посилання (постійні покажчики в С). Тобто, коли ви користуєтесь val x = new MutableFoo(), ви зможете змінити об’єкт, на який xвказує, але ви не зможете змінити, на які об’єктні x точки. Якщо ви використовуєте, справедливе протилежне var x = new ImmutableFoo(). Отримавши мою первинну пораду: якщо вам не потрібно змінювати, на який об’єкт посилаються точки, використовуйте vals.

Найкращий спосіб відповісти на це прикладом. Припустимо, у нас є якийсь процес просто збирання номерів з якоїсь причини. Ми хочемо зареєструвати ці номери і надішлемо колекцію в інший процес для цього.

Звичайно, ми все ще збираємо номери після того, як відправимо колекцію до лісоруба. Скажімо, є деякий накладний процес у процесі реєстрації, який затримує фактичну реєстрацію. Сподіваємось, ви зможете побачити, куди це йде.

Якщо ми зберігаємо цю колекцію в мутаційному вигляді val(мутаційному, оскільки ми постійно додаємо до неї), це означає, що процес, що веде журнал, буде дивитись на той самий об’єкт, який все ще оновлюється нашим процесом колекції. Ця колекція може бути оновлена ​​в будь-який час, і тому, коли настає час для входу, ми можемо насправді не реєструвати надіслану нами колекцію.

Якщо ми використовуємо незмінний var, ми надсилаємо незмінна структура даних в реєстратор. Коли ми додаємо більше чисел в нашу колекцію, ми будемо замінювати OUR varз новими непорушними структурами даних . Це не означає, що колекція, що надсилається до реєстратора, замінена! Він досі посилається на колекцію, яку він надіслав. Тож наш реєстратор дійсно запише отриману колекцію.

Я думаю, що приклади в цій публікації в блозі пролиють більше світла, оскільки питання, яке комбо використовувати, стає ще важливішим у сценаріях паралельності: важливість незмінності для одночасності . І хоча ми до цього звертаємо увагу на переважне використання синхронізованого vs @volatile vs щось на зразок AtomicReference: три інструменти

var immutable vs. val mutable

Окрім багатьох відмінних відповідей на це питання. Ось простий приклад, який ілюструє потенційні небезпеки val mutable:

Змінні об'єкти можуть бути змінені всередині методів, які приймають їх за параметри, тоді як перепризначення заборонено.

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

Результат:

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

Щось подібного не може статися з цим var immutable, оскільки перепризначення заборонено:

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

Призводить до:

error: reassignment to val

Оскільки параметри функції розглядаються як valтаке перепризначення, не дозволяється.