Scala'da val-değişkene karşı var-immutable

Değişmez bir koleksiyonla var kullanmak yerine değişebilen bir koleksiyonla val'in ne zaman kullanılacağına ilişkin Scala'da herhangi bir kılavuz var mı? Yoksa gerçekten değişmez bir koleksiyonla vali mi hedeflemelisiniz?

Her iki koleksiyon türünün de olması bana çok fazla seçenek veriyor ve çoğu zaman bu seçimi nasıl yapacağımı bilmiyorum.

Bu oldukça yaygın bir soru. Zor olan, kopyaları bulmaktır.

Referans şeffaflığı için çabalamalısınız . Ne demek olduğunu ben bir ifade "e" varsa, ben yapabilirim, yani val x = e, ve değiştirme eile x. Bu, değişebilirliği bozan özelliktir. Bir tasarım kararı vermeniz gerektiğinde, referans şeffaflığı en üst düzeye çıkarın.

Pratik bir mesele olarak, yöntem-yerel var, yöntemden kaçmadığı variçin var olan en güvenlisidir . Yöntem kısaysa, daha da iyi. Değilse, diğer yöntemleri çıkararak onu azaltmaya çalışın.

Öte yandan, değişken bir koleksiyon, olmasa bile kaçma potansiyeline sahiptir . Kodu değiştirirken, daha sonra başka yöntemlere geçirmek veya iade etmek isteyebilirsiniz. Bu, referans şeffaflığı bozan türden bir şey.

Bir nesnede (bir tarlada), hemen hemen aynı şey olur, ancak daha vahim sonuçları olur. Her iki durumda da nesnenin durumu olur ve bu nedenle, referans şeffaflığı bozulur. Ancak değiştirilebilir bir koleksiyona sahip olmak, nesnenin kendisi bile onu kimin değiştirdiğinin kontrolünü kaybedebileceği anlamına gelir.

Değişmez koleksiyonlarla çalışıyorsanız ve bunları "değiştirmeniz" gerekiyorsa, örneğin bunlara bir döngüde öğeler eklemeniz gerekiyorsa, o zaman varelde edilen koleksiyonu bir yerde depolamanız gerektiğinden s kullanmanız gerekir. Yalnızca değişmez koleksiyonlardan okuyorsanız, vals kullanın .

Genel olarak, referansları ve nesneleri karıştırmadığınızdan emin olun. vals değişmez referanslardır (C'de sabit işaretçiler). Kullandığınızda olduğunu, val x = new MutableFoo(), sen mümkün olacak nesneyi değiştirmek için bu xkadar puan ancak mümkün olmayacaktır nesne için değişikliğine x puan. Eğer kullanırsanız tam tersi geçerlidir var x = new ImmutableFoo(). İlk tavsiyemi alırım: Referans noktasını hangi nesneye çevirmeniz gerekmiyorsa, vals kullanın .

Buna cevap vermenin en iyi yolu bir örnek vermektir. Bir nedenden ötürü sadece sayıları toplamak için bir işlemimiz olduğunu varsayalım. Bu numaraları kaydetmek istiyoruz ve koleksiyonu bunu yapmak için başka bir işleme göndereceğiz .

Elbette, koleksiyonu kaydediciye gönderdikten sonra hala sayı topluyoruz. Diyelim ki günlük kaydı sürecinde, gerçek günlüğe kaydetmeyi geciktiren bazı ek yükler var. Umarım bunun nereye gittiğini görebilirsiniz.

Bu koleksiyonu bir değişken val(değişken, çünkü sürekli eklemekte olduğumuz için) depolarsak , bu, günlüğe kaydetmeyi yapan işlemin, toplama sürecimiz tarafından güncellenmekte olan aynı nesneye bakacağı anlamına gelir . Bu koleksiyon herhangi bir zamanda güncellenebilir ve bu nedenle günlüğe kaydetme zamanı geldiğinde gönderdiğimiz koleksiyonu gerçekten günlüğe kaydetmiyor olabiliriz.

Bir vardeğişmez kullanırsak, kaydediciye değişmez bir veri yapısı göndeririz. Bizim koleksiyonuna fazla numara eklemek, biz olacak yerine Our varbir ile yeni değişmez veri yapısı . Bu, kaydediciye gönderilen koleksiyonun değiştirildiği anlamına gelmez! Hala gönderildiği koleksiyona atıfta bulunuyor. Böylece kaydedicimiz aldığı koleksiyonu gerçekten kaydedecek.

Eşzamanlılık senaryolarında hangi kombinasyonun kullanılacağı sorusu daha da önemli hale geldiğinden, bu blog gönderisindeki örneklerin daha fazla ışık tutacağını düşünüyorum: eşzamanlılık için değişmezliğin önemi . Ve biz oradayken, atomicReference gibi senkronize ve @volatile karşılaştırmasının tercih edilen kullanımına dikkat edin: üç araç

var immutable vs. val mutable

Bu soruya birçok mükemmel cevaba ek olarak. İşte olası tehlikeleri gösteren basit bir örnek val mutable:

Değişken nesneler, onları parametre olarak alan yöntemler içinde değiştirilebilir, ancak yeniden atamaya izin verilmez.

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

Sonuç:

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

Yeniden var immutableatamaya izin verilmediğinden bunun gibi bir şey olamaz :

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

Sonuçlar:

error: reassignment to val

İşlev parametreleri, valbu yeniden atamaya izin verilmediği için ele alındığından .