val-mutable versus var-immutable w Scali

Czy w Scali są jakieś wytyczne dotyczące tego, kiedy używać val ze zmienną kolekcją, a kiedy var z niezmienną kolekcją? A może naprawdę powinieneś dążyć do val z niezmienną kolekcją?

Fakt, że istnieją oba rodzaje kolekcji, daje mi duży wybór, a często nie wiem, jak tego dokonać.

To dość powszechne pytanie. Trudno jest znaleźć duplikaty.

Należy dążyć do referencyjnej przejrzystości . Co to znaczy, że jeśli mam wyrażenie „e”, mogę zrobić val x = ei wymienić ez x. To jest właściwość, którą łamie zmienność. Zawsze, gdy musisz podjąć decyzję projektową, maksymalizuj ją, aby uzyskać referencyjną przejrzystość.

Z praktycznego punktu widzenia metoda lokalna varjest najbezpieczniejsza z varistniejących, ponieważ nie wymyka się metodzie. Jeśli metoda jest krótka, jeszcze lepsza. Jeśli tak nie jest, spróbuj go zmniejszyć, wyodrębniając inne metody.

Z drugiej strony zmienna kolekcja ma potencjał do ucieczki, nawet jeśli tak się nie stanie. Zmieniając kod, możesz chcieć przekazać go innym metodom lub zwrócić. To jest rodzaj rzeczy, która łamie referencyjną przejrzystość.

Na obiekcie (polu) dzieje się prawie to samo, ale z bardziej tragicznymi konsekwencjami. Tak czy inaczej obiekt będzie miał stan, a zatem złamie przezroczystość referencyjną. Ale posiadanie zmiennej kolekcji oznacza, że ​​nawet sam obiekt może stracić kontrolę nad tym, kto go zmienia.

Jeśli pracujesz z niezmiennymi kolekcjami i musisz je „zmodyfikować”, na przykład dodać do nich elementy w pętli, musisz użyć vars, ponieważ musisz gdzieś przechowywać wynikową kolekcję. Jeśli czytasz tylko z niezmiennych kolekcji, użyj vals.

Ogólnie upewnij się, że nie pomylisz odniesień i obiektów. vals są niezmiennymi referencjami (stałe wskaźniki w C). Oznacza to, że kiedy używasz val x = new MutableFoo(), będziesz mógł zmienić obiekt, który xwskazuje, ale nie będziesz w stanie zmienić tego, który obiekt x wskazuje. Odwrotnie jest, jeśli używasz var x = new ImmutableFoo(). Podchodzę do mojej wstępnej rady: jeśli nie musisz zmieniać obiektu, do którego odnosi się punkt odniesienia, użyj vals.

Najlepszym sposobem odpowiedzi na to jest przykład. Załóżmy, że z jakiegoś powodu mamy jakiś proces po prostu zbierający liczby. Chcemy zarejestrować te numery i wyślemy kolekcję do innego procesu, aby to zrobić.

Oczywiście po wysłaniu kolekcji do rejestratora nadal zbieramy numery. Załóżmy, że proces rejestrowania jest obciążony, co opóźnia faktyczne rejestrowanie. Mam nadzieję, że widzisz, dokąd to zmierza.

Jeśli przechowujemy tę kolekcję jako zmienną val(zmienną, ponieważ stale do niej dodajemy), oznacza to, że proces rejestrujący będzie szukał tego samego obiektu, który wciąż jest aktualizowany przez nasz proces zbierania. Ta kolekcja może zostać zaktualizowana w dowolnym momencie, więc kiedy nadejdzie czas na rejestrację, możemy w rzeczywistości nie rejestrować kolekcji, którą wysłaliśmy.

Jeśli używamy niezmiennej var, wysyłamy niezmienną strukturę danych do rejestratora. Kiedy dodać więcej numerów do naszej kolekcji, będziemy zastępując Our varz nowym niezmiennej struktury danych . Nie oznacza to, że zbiór przesłany do rejestratora zostanie zastąpiony! Nadal odwołuje się do kolekcji, którą wysłał. Zatem nasz logger rzeczywiście zarejestruje otrzymaną kolekcję.

Myślę, że przykłady w tym wpisie na blogu rzucą więcej światła, ponieważ kwestia, którego kombinacji użyć, staje się jeszcze ważniejsza w scenariuszach współbieżności: znaczenie niezmienności dla współbieżności . A skoro już o tym mowa, zwróć uwagę na preferowane użycie synchronized vs @volatile vs czegoś takiego jak AtomicReference: trzy narzędzia

var immutable vs. val mutable

Oprócz wielu doskonałych odpowiedzi na to pytanie. Oto prosty przykład, który ilustruje potencjalne zagrożenia val mutable:

Mutowalne obiekty można modyfikować wewnątrz metod, które przyjmują je jako parametry, podczas gdy ponowne przypisywanie jest niedozwolone.

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

Wynik:

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

Coś takiego nie może się zdarzyć var immutable, ponieważ zmiana przypisania jest niedozwolona:

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

Prowadzi do:

error: reassignment to val

Ponieważ parametry funkcji są traktowane jako valtakie ponowne przypisanie, nie jest dozwolone.