多字段User Struct优雅初始化方案推荐咨询

针对你遇到的字段多、初始化冗长，且注册场景需要默认值的问题，推荐以下几种方案，可根据实际场景选择：

1. 优化版Builder设计模式（解决手动设置大量字段的痛点） #

常规Builder需要手动设置所有字段，但可以通过预设默认值+链式修改可选字段的方式优化，让注册场景只需传入必填项，可选字段自动使用默认值。

代码示例： #

public struct User {
    var email: String
    var uid: String
    var userSettings: UserSettings
    var userProfile: UserProfile
    
    // 私有初始化，限制只能通过Builder创建实例
    private init(email: String, uid: String, userSettings: UserSettings, userProfile: UserProfile) {
        self.email = email
        self.uid = uid
        self.userSettings = userSettings
        self.userProfile = userProfile
    }
    
    // Builder结构体，封装初始化逻辑
    public struct Builder {
        // 存储待构建的字段
        private var email: String?
        private var uid: String?
        private var userSettings: UserSettings?
        private var userProfile: UserProfile?
        
        // 注册场景专用初始化：自动填充默认值
        public init(forRegistration credentials: AuthCredentials, profileDownloadUrl: [String], uid: String) {
            guard let birthday = credentials.birthday,
                  let firstName = credentials.firstName,
                  let lastName = credentials.lastName,
                  let gender = credentials.gender,
                  let preference = credentials.preference,
                  let geoHash = credentials.location?.geoHash,
                  let latitude = credentials.location?.latitude,
                  let longitude = credentials.location?.longitude,
                  let email = credentials.email else {
                fatalError("注册必填信息不完整")
            }
            
            // 预设UserProfile默认值（bio、school等为空）
            self.userProfile = UserProfile(
                birthday: birthday,
                profilePictures: profileDownloadUrl,
                firstName: firstName,
                lastName: lastName,
                bio: "",
                school: "",
                occupation: ""
            )
            
            // 预设UserSettings默认值
            self.userSettings = UserSettings(
                minSeekingAge: MAX_AGE,
                maxSeekingAge: MIN_AGE,
                distanceRange: MAX_DISTANCE_RANGE,
                gender: gender,
                preference: preference,
                geoHash: geoHash,
                latitude: latitude,
                longitude: longitude
            )
            
            self.email = email
            self.uid = uid
        }
        
        // 链式修改可选字段的方法
        public func setBio(_ bio: String) -> Builder {
            var copy = self
            copy.userProfile?.bio = bio
            return copy
        }
        
        public func setSchool(_ school: String) -> Builder {
            var copy = self
            copy.userProfile?.school = school
            return copy
        }
        
        // 其他可选字段的修改方法同理...
        
        // 构建最终User实例
        public func build() -> User? {
            guard let email = email,
                  let uid = uid,
                  let userSettings = userSettings,
                  let userProfile = userProfile else {
                return nil
            }
            return User(email: email, uid: uid, userSettings: userSettings, userProfile: userProfile)
        }
    }
}

// 使用示例：注册场景
let newUser = User.Builder(forRegistration: credentials, profileDownloadUrl: imageUrls, uid: userUid)
    .setBio("热爱户外旅行") // 可选修改，不调用则用默认空值
    .build()

优势： #

• 注册场景无需手动设置默认值，只需处理必填项
• 链式调用可读性高，灵活支持字段修改
• 初始化逻辑集中在Builder，User结构体保持简洁

2. 利用Swift默认参数简化初始化 #

给UserProfile和UserSettings的初始化方法添加默认参数，让创建实例时自动填充默认值，无需手动重复编写默认逻辑。

代码示例： #

首先修改子结构体的初始化：

public struct UserProfile {
    var birthday: Date
    var profilePictures: [String]
    var firstName: String
    var lastName: String
    var bio: String
    var school: String
    var occupation: String
    
    // 带默认参数的初始化方法
    init(birthday: Date, profilePictures: [String], firstName: String, lastName: String,
         bio: String = "", school: String = "", occupation: String = "") {
        self.birthday = birthday
        self.profilePictures = profilePictures
        self.firstName = firstName
        self.lastName = lastName
        self.bio = bio
        self.school = school
        self.occupation = occupation
    }
    
    // 保留从userNode初始化的方法
    init?(userNode: [String: Any]) {
        // 原有逻辑...
    }
}

public struct UserSettings {
    var minSeekingAge: Int
    var maxSeekingAge: Int
    var distanceRange: Double
    var gender: String
    var preference: String
    var geoHash: String
    var latitude: Double
    var longitude: Double
    
    // 带默认参数的初始化方法
    init(minSeekingAge: Int = MAX_AGE, maxSeekingAge: Int = MIN_AGE, distanceRange: Double = MAX_DISTANCE_RANGE,
         gender: String, preference: String, geoHash: String, latitude: Double, longitude: Double) {
        self.minSeekingAge = minSeekingAge
        self.maxSeekingAge = maxSeekingAge
        self.distanceRange = distanceRange
        self.gender = gender
        self.preference = preference
        self.geoHash = geoHash
        self.latitude = latitude
        self.longitude = longitude
    }
    
    // 保留从userNode初始化的方法
    init?(userNode: [String: Any]) {
        // 原有逻辑...
    }
}

然后简化User的初始化：

public struct User {
    var email: String
    var userSettings: UserSettings
    var userProfile: UserProfile
    var uid: String
    
    init?(with userNode: [String: Any]) {
        guard let userProfile = UserProfile(userNode: userNode),
              let userSettings = UserSettings(userNode: userNode),
              let email = userNode[EMAIL] as? String,
              let uid = userNode[UID] as? String else { return nil }
        
        self.userProfile = userProfile
        self.userSettings = userSettings
        self.email = email
        self.uid = uid
    }
    
    // 简化后的注册初始化
    init?(with credentials: AuthCredentials, profileDownloadUrl: [String], uid: String) {
        guard let birthday = credentials.birthday,
              let firstName = credentials.firstName,
              let lastName = credentials.lastName,
              let gender = credentials.gender,
              let preference = credentials.preference,
              let geoHash = credentials.location?.geoHash,
              let latitude = credentials.location?.latitude,
              let longitude = credentials.location?.longitude,
              let email = credentials.email else {
            return nil
        }
        
        // 自动使用默认参数，无需手动写默认值
        self.userProfile = UserProfile(
            birthday: birthday,
            profilePictures: profileDownloadUrl,
            firstName: firstName,
            lastName: lastName
        )
        
        self.userSettings = UserSettings(
            gender: gender,
            preference: preference,
            geoHash: geoHash,
            latitude: latitude,
            longitude: longitude
        )
        
        self.email = email
        self.uid = uid
    }
}

优势： #

• 完全贴合Swift语言特性，代码改动最小
• 默认值集中在子结构体的初始化方法，维护方便
• 原有初始化逻辑无需大幅重构

3. 工厂模式（剥离初始化逻辑） #

创建专门的UserFactory类，封装不同场景的User创建逻辑，让User结构体只专注于数据存储，分离职责。

代码示例： #

public class UserFactory {
    // 从userNode加载已有用户
    static func createUser(from userNode: [String: Any]) -> User? {
        guard let userProfile = UserProfile(userNode: userNode),
              let userSettings = UserSettings(userNode: userNode),
              let email = userNode[EMAIL] as? String,
              let uid = userNode[UID] as? String else { return nil }
        
        return User(email: email, userSettings: userSettings, userProfile: userProfile, uid: uid)
    }
    
    // 创建新注册用户，自动填充默认值
    static func createNewUser(with credentials: AuthCredentials, profileDownloadUrl: [String], uid: String) -> User? {
        guard let birthday = credentials.birthday,
              let firstName = credentials.firstName,
              let lastName = credentials.lastName,
              let gender = credentials.gender,
              let preference = credentials.preference,
              let geoHash = credentials.location?.geoHash,
              let latitude = credentials.location?.latitude,
              let longitude = credentials.location?.longitude,
              let email = credentials.email else {
            return nil
        }
        
        let defaultProfile = UserProfile(
            birthday: birthday,
            profilePictures: profileDownloadUrl,
            firstName: firstName,
            lastName: lastName,
            bio: "",
            school: "",
            occupation: ""
        )
        
        let defaultSettings = UserSettings(
            minSeekingAge: MAX_AGE,
            maxSeekingAge: MIN_AGE,
            distanceRange: MAX_DISTANCE_RANGE,
            gender: gender,
            preference: preference,
            geoHash: geoHash,
            latitude: latitude,
            longitude: longitude
        )
        
        return User(email: email, userSettings: defaultSettings, userProfile: defaultProfile, uid: uid)
    }
}

// 使用示例
let existingUser = UserFactory.createUser(from: userNode)
let newUser = UserFactory.createNewUser(with: credentials, profileDownloadUrl: imageUrls, uid: userUid)

优势： #

• User结构体无需承担初始化逻辑，职责单一
• 不同场景的创建逻辑集中在工厂类，便于统一维护
• 调用方代码更简洁，只需调用工厂方法即可

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