如何实现字典中变量像类静态变量一样全局可更新生效？

你的核心问题在于：Int是值类型，你每次把Main1.value1放进字典时，都是复制了它的当前值，而不是引用。修改字典里的那个值，只是修改了局部副本，根本没碰到底层的静态变量，所以Main2里取到的还是初始的1，加1后输出2，达不到你要的全局更新效果。

下面给你两种实用的解决方案，按需选择：

方案一：直接通过Key映射修改原静态变量 #

如果你的变量不多，直接用switch判断key来操作静态变量最直接，代码清晰：

class Main1 {
    static var value1: Int = 1
    
    func updateValue(_ key: String) {
        switch key {
        case "value1":
            Main1.value1 += 1
            print(Main1.value1)
        default:
            return
        }
    }
}

class Main2 {
    func updateValue(_ key: String) {
        switch key {
        case "value1":
            Main1.value1 += 1
            print(Main1.value1)
        default:
            return
        }
    }
}

// 测试输出
Main1().updateValue("value1") // 输出2
Main2().updateValue("value1") // 输出3，符合你的期望

如果变量很多，不想写一堆switch，可以用字典存"获取/设置"闭包，实现更灵活的映射：

class Main1 {
    static var value1: Int = 1
    static var value2: Int = 10
    
    // 用字典存储每个key对应的 getter 和 setter 闭包
    private static let variableMap: [String: (() -> Int, (Int) -> Void)] = [
        "value1": (
            { Main1.value1 }, // 读取当前值的闭包
            { Main1.value1 = $0 } // 更新值的闭包
        ),
        "value2": (
            { Main1.value2 },
            { Main1.value2 = $0 }
        )
    ]
    
    func updateValue(_ key: String) {
        guard let (getCurrent, setNew) = Main1.variableMap[key] else { return }
        let newValue = getCurrent() + 1
        setNew(newValue)
        print(newValue)
    }
}

class Main2 {
    func updateValue(_ key: String) {
        guard let (getCurrent, setNew) = Main1.variableMap[key] else { return }
        let newValue = getCurrent() + 1
        setNew(newValue)
        print(newValue)
    }
}

// 测试输出
Main1().updateValue("value1") // 输出2
Main2().updateValue("value1") // 输出3
Main1().updateValue("value2") // 输出11

方案二：把值类型包装成引用类型 #

因为引用类型（比如类）在字典里存储的是实例引用，修改引用的属性会直接改动原实例。我们可以把Int包装成一个简单的类：

// 包装Int的引用类型类
class WrappedInt {
    var value: Int
    init(_ initialValue: Int) {
        self.value = initialValue
    }
}

class Main1 {
    static var value1 = WrappedInt(1)
    
    func updateValue(_ key: String) {
        let dict: [String: WrappedInt] = ["value1": Main1.value1]
        guard let wrapped = dict[key] else { return }
        wrapped.value += 1
        print(wrapped.value)
    }
}

class Main2 {
    func updateValue(_ key: String) {
        let dict: [String: WrappedInt] = ["value1": Main1.value1]
        guard let wrapped = dict[key] else { return }
        wrapped.value += 1
        print(wrapped.value)
    }
}

// 测试输出
Main1().updateValue("value1") // 输出2
Main2().updateValue("value1") // 输出3，符合期望

这种方式的好处是不用改动太多原有的字典使用逻辑，只需要把静态变量换成包装类实例即可。

内容的提问来源于stack exchange，提问作者Wizzardzz