标签: immutability

我已经在许多地方读过,公开公开字段并不是一个好主意,因为如果你以后想要更改属性,则必须重新编译使用你的类的所有代码.

但是,在不可变类的情况下,我不明白为什么你需要更改为属性 - 毕竟你不会在'set'中添加逻辑.

对此有任何想法,我错过了什么吗？

差异的例子,对于那些比文本更容易阅读代码的人:)

//Immutable Tuple using public readonly fields
public class Tuple<T1,T2>
{
     public readonly T1 Item1;
     public readonly T2 Item2;
     public Tuple(T1 item1, T2 item2)
     {
         Item1 = item1;
         Item2 = item2;
     }
}

//Immutable Tuple using public properties and private readonly fields
public class Tuple<T1,T2>
{
     private readonly T1 _Item1;
     private readonly T2 _Item2;
     public Tuple(T1 item1, T2 item2)
     {
         _Item1 = item1;
         _Item2 = item2;
     }
     public T1 Item1 { get { return _Item1; …

请考虑以下代码:

$ irb
> s = "asd"
> s.object_id   # prints 2171223360
> s[0] = ?z     # s is now "zsd"
> s.object_id   # prints 2171223360 (same as before)
> s += "hello"  # s is now "zsdhello"
> s.object_id   # prints 2171224560 (now it's different)

似乎可以在不创建新字符串的情况下更改单个字符.但是,附加到字符串显然会创建一个新字符串.

Ruby中的字符串是否可变？

所以我有一些相当广泛的功能代码,主要数据类型是不可变的结构/类.通过制作成员变量和任何方法const,我一直在声明不变性的方式是"几乎不可变的".

struct RockSolid {
   const float x;
   const float y;
   float MakeHarderConcrete() const { return x + y; }
}

这实际上是C++中"我们应该这样做"的方式吗？或者,还有更好的方法？

所以,我有List a:

let a = Immutable.List([1])

和清单b:

let b = Immutable.List([2, 3])

我想union === List([1, 2, 3])从他们那里得到List .

我试着将它们合并在一起:

let union = a.merge(b); // List([2, 3])

看起来merge方法操作索引,而不是值,所以覆盖第一项的List a第一项List b.所以,我的问题是什么是获得多个列表联合的最简单方法(理想情况下不会迭代它们和其他额外的操作).

我需要将可变列表对象转换为不可变列表,在java中可能的方式是什么.

public void action() {
    List<MutableClass> mutableList = Arrays.asList(new MutableClass("san", "UK", 21), new MutableClass("peter", "US", 34));
    List<MutableClass> immutableList = immutateList(mutableList);
}

public List<MutableClass> immutateList(List<MutableClass> mutableList){
    //some code here to make this beanList immutable
    //ie. objects and size of beanList should not be change.
    //ie. we cant add new object here.
    //ie. we cant remove or change existing one.
}

MutableClass

final class MutableClass {
    final String name;    
    final String address;
    final int age;
    MutableClass(String name, String address, int age) { …

class Unit {
    private readonly string name;
    private readonly double scale;

    public Unit(string name, double scale) {
        this.name = name;
        this.scale = scale,
    }

    public string Name { get { return name; } }
    public string Scale { get { return scale; } }

    private static Unit gram = new Unit("Gram", 1.0);

    public Unit Gram { get { return gram; } }
}

多个线程可以访问Unit.Gram.为什么多个线程同时读取都可以Unit.Gram.Title？

我担心的是他们指的是相同的内存位置.一个线程开始读取该内存,那么它是不是"被锁定"了呢？.NET是否处理下面这个关键部分的同步？或者我认为同步阅读需要同步？

字符串在Ruby中是否可变？根据文件做

str = "hello"
str = str + " world"

使用值创建一个新的字符串对象,"hello world"但是当我们这样做时

str = "hello"
str << " world"

它没有提到它创建了一个新对象,它是否会改变str对象,现在它将具有值"hello world"？

我了解到,如果变量未使用显式声明为可变mut,则变为不可变(在声明后不能更改).那为什么我们const在Rust中有关键字？他们不一样吗？如果没有,它们有何不同？

我来自C++背景,目前我正在学习Java.当我尝试使用某些第三方库时出现了一个问题.如何确定对作为参数的对象引用的方法的调用是否修改了对象？在C++中,由于使用了const关键字,因此很清楚.如果方法签名是:

void foo(Boo& boo);

我知道引用的对象可能会被修改,而如果方法签名是:

void foo(const Boo& boo);

编译器保证不会修改引用的对象.

我没有在Java中看到类似的东西,因为只有引用本身可以被声明为final,而不是引用的对象,并且最终的参数在第一个地方没有多大意义,因为它无论如何都是通过值传递的.因此,当我看到一个方法,如:

void foo(Boo boo) {...}

如何确定boo引用的对象是否在函数体内修改(可能使用注释)？如果没有办法知道,是否有一些广泛使用的约定或一些最佳实践来避免混淆和错误？

为什么Redux中的对象应该是不可变的？我知道一些框架如Angular2将使用onPush并且可以利用不变性来比较视图状态以便更快地呈现,但我想知道是否还有其他原因因为Redux是框架无关的,但它在自己的文档中提到使用不变性(无论框架如何).

感谢任何反馈.