val-mutable contro var-immutable in Scala

Esistono linee guida in Scala su quando usare val con una collezione mutabile rispetto all'uso di var con una collezione immutabile? O dovresti davvero puntare a val con una collezione immutabile?

Il fatto che ci siano entrambi i tipi di collezione mi dà molta scelta e spesso non so come fare quella scelta.

Domanda abbastanza comune, questa. La cosa difficile è trovare i duplicati.

Dovresti lottare per la trasparenza referenziale . Ciò significa che, se ho un'espressione "e", potrei fare una val x = ee sostituirla econ x. Questa è la proprietà che la mutabilità interrompe. Ogni volta che è necessario prendere una decisione di progettazione, massimizza la trasparenza referenziale.

In pratica, un metodo locale varè il più sicuro varche esista, poiché non sfugge al metodo. Se il metodo è breve, ancora meglio. Se non lo è, prova a ridurlo estraendo altri metodi.

D'altra parte, una collezione mutevole ha il potenziale per sfuggire, anche se non lo fa. Quando si modifica il codice, è possibile passarlo ad altri metodi o restituirlo. Questo è il genere di cose che infrange la trasparenza referenziale.

Su un oggetto (un campo) accade più o meno la stessa cosa, ma con conseguenze più disastrose. In entrambi i casi l'oggetto avrà uno stato e, quindi, interromperà la trasparenza referenziale. Ma avere una collezione mutevole significa che anche l'oggetto stesso potrebbe perdere il controllo di chi lo sta cambiando.

Se lavori con raccolte immutabili e hai bisogno di "modificarle", ad esempio, aggiungendovi elementi in un ciclo, allora devi usare vars perché devi memorizzare la raccolta risultante da qualche parte. Se leggi solo da raccolte immutabili, usa vals.

In generale, assicurati di non confondere riferimenti e oggetti. vals sono riferimenti immutabili (puntatori costanti in C). Cioè, quando lo usi val x = new MutableFoo(), sarai in grado di cambiare l'oggetto a cui xpunta, ma non sarai in grado di cambiare a quale oggetto x punta. Se usi var x = new ImmutableFoo(). Riprendo il mio consiglio iniziale: se non hai bisogno di cambiare a quale oggetto punta un riferimento, usa vals.

Il modo migliore per rispondere a questa domanda è con un esempio. Supponiamo di avere qualche processo che raccoglie semplicemente i numeri per qualche motivo. Vorremmo registrare questi numeri e invieremo la raccolta a un altro processo per farlo.

Naturalmente, stiamo ancora raccogliendo numeri dopo aver inviato la raccolta al logger. E diciamo che c'è un sovraccarico nel processo di registrazione che ritarda la registrazione effettiva. Spero che tu possa vedere dove sta andando.

Se memorizziamo questa raccolta in un mutabile val(mutabile perché la stiamo aggiungendo continuamente), ciò significa che il processo che esegue la registrazione guarderà lo stesso oggetto che è ancora aggiornato dal nostro processo di raccolta. Quella raccolta può essere aggiornata in qualsiasi momento, quindi quando è il momento di accedere potremmo non registrare effettivamente la raccolta che abbiamo inviato.

Se usiamo un immutabile var, inviamo una struttura dati immutabile al logger. Quando aggiungeremo più numeri alla nostra raccolta, sostituiremo il nostro varcon una nuova struttura dati immutabile . Questo non significa che la raccolta inviata al logger venga sostituita! Fa ancora riferimento alla raccolta che è stata inviata. Quindi il nostro logger registrerà effettivamente la raccolta che ha ricevuto.

Penso che gli esempi in questo post del blog faranno più luce, poiché la questione di quale combo usare diventa ancora più importante negli scenari di concorrenza: l' importanza dell'immutabilità per la concorrenza . E già che ci siamo, nota l'uso preferito di sincronizzato vs @volatile rispetto a qualcosa come AtomicReference: tre strumenti

var immutable vs. val mutable

Oltre a tante ottime risposte a questa domanda. Ecco un semplice esempio, che illustra i potenziali pericoli di val mutable:

Gli oggetti mutabili possono essere modificati all'interno di metodi, che li prendono come parametri, mentre la riassegnazione non è consentita.

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

Risultato:

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

Qualcosa del genere non può accadere var immutable, perché la riassegnazione non è consentita:

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

Risultati in:

error: reassignment to val

Poiché i parametri della funzione vengono trattati come valtale riassegnazione non è consentita.