Swift中能否同时定义并实例化隐式类型？UserDefaults场景需求

当然可以！Swift的类型推断和合成初始化器完全支持我们在定义隐式类型的同时完成实例化，而且完全不需要手动编写初始化器来设置成员——这恰好能解决你构建层级化UserDefaults键结构的需求。

我结合你的需求，整理了两种实用的实现方案：

方案1：链式节点式层级键生成（轻量灵活） #

这种方式通过链式调用生成层级节点，自动拼接键路径，完全不需要手动维护复杂的键字符串：

import Foundation

// 基础节点类，负责键拼接和UserDefaults操作
struct DefaultsNode {
    private let parentKey: String
    
    // 根节点初始化
    init(rootKey: String = "") {
        self.parentKey = rootKey
    }
    
    // 子节点初始化（私有，仅通过child方法调用）
    private init(parentKey: String) {
        self.parentKey = parentKey
    }
    
    // 生成完整的层级键
    private func fullKey(for childKey: String) -> String {
        guard !parentKey.isEmpty else { return childKey }
        return "\(parentKey).\(childKey)"
    }
    
    // MARK: - 常用UserDefaults操作方法
    func set(_ value: Any?, forKey key: String) {
        UserDefaults.standard.set(value, forKey: fullKey(for: key))
    }
    
    func string(forKey key: String) -> String? {
        UserDefaults.standard.string(forKey: fullKey(for: key))
    }
    
    func bool(forKey key: String) -> Bool {
        UserDefaults.standard.bool(forKey: fullKey(for: key))
    }
    
    // 按需添加其他类型的读取方法...
    
    // 生成子节点，实现层级链式调用
    func child(_ key: String) -> DefaultsNode {
        DefaultsNode(parentKey: fullKey(for: key))
    }
}

// 同时定义并实例化整个层级结构
let appDefaults = DefaultsNode(rootKey: "MyApp")
    .child("User")
    .child("Profile")

// 使用示例：自动生成键 "MyApp.User.Profile.name"
appDefaults.set("Alice", forKey: "name")
let userName = appDefaults.string(forKey: "name") // 输出 "Alice"

方案2：结构化嵌套容器（更直观的层级结构） #

如果你想要更贴近代码结构的层级定义，可以用嵌套结构体实现，所有子容器会自动继承父键并拼接，完全不需要手动初始化成员：

import Foundation

struct DefaultsContainer {
    let parentKey: String
    
    // 根容器初始化
    init(parentKey: String = "") {
        self.parentKey = parentKey
    }
    
    // 直接定义并实例化隐式子容器，自动拼接父键
    let user = UserContainer(parentKey: "")
    let settings = SettingsContainer(parentKey: "")
    
    // 用户相关子容器
    struct UserContainer {
        let parentKey: String
        
        init(parentKey: String) {
            self.parentKey = "\(parentKey).user"
        }
        
        // 继续嵌套子容器
        let profile = ProfileContainer(parentKey: "")
        
        struct ProfileContainer {
            let parentKey: String
            
            init(parentKey: String) {
                self.parentKey = "\(parentKey).profile"
            }
            
            // 封装具体的UserDefaults键，自动生成层级路径
            var name: String {
                get { UserDefaults.standard.string(forKey: "\(parentKey).name") ?? "" }
                set { UserDefaults.standard.set(newValue, forKey: "\(parentKey).name") }
            }
            
            var age: Int {
                get { UserDefaults.standard.integer(forKey: "\(parentKey).age") }
                set { UserDefaults.standard.set(newValue, forKey: "\(parentKey).age") }
            }
        }
    }
    
    // 设置相关子容器
    struct SettingsContainer {
        let parentKey: String
        
        init(parentKey: String) {
            self.parentKey = "\(parentKey).settings"
        }
        
        var darkMode: Bool {
            get { UserDefaults.standard.bool(forKey: "\(parentKey).darkMode") }
            set { UserDefaults.standard.set(newValue, forKey: "\(parentKey).darkMode") }
        }
    }
}

// 实例化整个容器，所有子节点自动完成键拼接
let appDefaults = DefaultsContainer()

// 使用示例：自动生成键 "user.profile.name"
appDefaults.user.profile.name = "Bob"
print(appDefaults.user.profile.name) // 输出 "Bob"

// 自动生成键 "settings.darkMode"
appDefaults.settings.darkMode = true
print(appDefaults.settings.darkMode) // 输出 true

为什么这符合你的需求？ #

1. 无静态成员：所有容器都是实例化的，你可以创建多个不同根键的DefaultsContainer实例，完全满足你需要实例化的要求。
2. 自动层级键生成：所有子节点的键会自动基于父节点拼接，不需要手动维护冗长的键字符串。
3. 无需手动初始化成员：Swift的合成初始化器会自动处理子容器的实例化，你只需要定义结构体的层级结构即可。

内容的提问来源于stack exchange，提问作者Mark A. Donohoe