val-mutable против var-immutable в Scala

Есть ли в Scala какие-либо рекомендации относительно того, когда использовать val с изменяемой коллекцией по сравнению с использованием var с неизменяемой коллекцией? Или вам действительно стоит стремиться к val с неизменной коллекцией?

Тот факт, что существуют оба типа коллекции, дает мне большой выбор, и часто я не знаю, как сделать этот выбор.

Довольно распространенный вопрос. Труднее всего найти дубликаты.

Вы должны стремиться к ссылочной прозрачности . Это означает, что, если у меня есть выражение «е», я могу составить a val x = eи заменить eна x. Это свойство, которое нарушает изменчивость. Всякий раз, когда вам нужно принять дизайнерское решение, максимизируйте ссылочную прозрачность.

С практической точки зрения, локальный метод varявляется наиболее безопасным из varсуществующих, поскольку он не ускользает от метода. Если способ короткий, то еще лучше. Если это не так, попробуйте уменьшить его, извлекая другие методы.

С другой стороны, изменчивая коллекция может ускользнуть, даже если этого не произойдет. При изменении кода вы можете затем передать его другим методам или вернуть. Такие вещи нарушают ссылочную прозрачность.

С объектом (полем) происходит примерно то же самое, но с более ужасными последствиями. В любом случае объект будет иметь состояние и, следовательно, нарушить ссылочную прозрачность. Но наличие изменяемой коллекции означает, что даже сам объект может потерять контроль над тем, кто его изменяет.

Если вы работаете с неизменяемыми коллекциями и вам нужно их «модифицировать», например, добавлять в них элементы в цикле, тогда вам нужно использовать vars, потому что вам нужно где-то хранить полученную коллекцию. Если вы читаете только из неизменяемых коллекций, используйте vals.

В общем, убедитесь, что вы не путаете ссылки и объекты. vals - неизменяемые ссылки (постоянные указатели в C). То есть при использовании val x = new MutableFoo()вы сможете изменить объект, на который xуказывает, но не сможете изменить, на какой объект x указывает. Обратное верно, если вы используете var x = new ImmutableFoo(). Продолжая свой первоначальный совет: если вам не нужно менять, на какой объект ориентируются, используйте vals.

Лучший способ ответить на этот вопрос - привести пример. Предположим, у нас есть процесс, по какой-то причине просто собирающий числа. Мы хотим записать эти числа и отправить коллекцию в другой процесс для этого.

Конечно, мы продолжаем собирать числа после того, как отправим их в регистратор. И предположим, что в процессе регистрации есть некоторые накладные расходы, которые задерживают фактическое ведение журнала. Надеюсь, вы видите, к чему это идет.

Если мы сохраняем эту коллекцию в изменяемом val(изменяемом, потому что мы постоянно добавляем к нему), это означает, что процесс, выполняющий ведение журнала, будет смотреть на тот же объект, который все еще обновляется нашим процессом сбора. Эта коллекция может быть обновлена ​​в любое время, поэтому, когда пришло время регистрировать, мы можем фактически не регистрировать отправленную коллекцию.

Если мы используем неизменяемый var, мы отправляем неизменяемую структуру данных в регистратор. Когда мы добавляем больше чисел в нашу коллекцию, мы будем заменять OUR varс новыми непреложными структурами данных . Это не означает, что коллекция, отправленная в регистратор, заменена! Он по-прежнему ссылается на отправленную коллекцию. Таким образом, наш регистратор действительно регистрирует полученную коллекцию.

Я думаю, что примеры в этом сообщении в блоге прольют больше света, поскольку вопрос о том, какую комбинацию использовать, становится еще более важным в сценариях параллелизма: важность неизменности для параллелизма . И пока мы занимаемся этим, обратите внимание на предпочтительное использование synchronized и @volatile по сравнению с чем-то вроде 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это переназначение недопустимо.