Question

struct ContentView: View {
@State var settingsConfiguration: Settings
    struct Settings {
        var passwordLength: Double = 20
        var moreSpecialCharacters: Bool = false
        var specialCharacters: Bool = false
        var lowercaseLetters: Bool = true
        var uppercaseLetters: Bool = true
        var numbers: Bool = true
        var space: Bool = false
    }
  var body: some View {
    VStack {
                HStack {
                    Text("Password Length: \(Int(settingsConfiguration.passwordLength))")
                    Spacer()
                    Slider(value: $settingsConfiguration.passwordLength, from: 1, through: 512)
                }
                Toggle(isOn: $settingsConfiguration.moreSpecialCharacters) {
                    Text("More Special Characters")
                }
                Toggle(isOn: $settingsConfiguration.specialCharacters) {
                    Text("Special Characters")
                }
                Toggle(isOn: $settingsConfiguration.space) {
                    Text("Spaces")
                }
                Toggle(isOn: $settingsConfiguration.lowercaseLetters) {
                    Text("Lowercase Letters")
                }
                Toggle(isOn: $settingsConfiguration.uppercaseLetters) {
                    Text("Uppercase Letters")
                }
                Toggle(isOn: $settingsConfiguration.numbers) {
                    Text("Numbers")
                }
                Spacer()
                }
                .padding(.all)
                .frame(width: 500, height: 500)
  }
}

所以我在这里有所有这些代码，我想使用UserDefaults在更改开关或滑动滑块时保存设置，并在应用启动时检索所有这些数据，但是我不知道该如何使用使用SwiftUI的UserDefaults（或者一般来说是UserDefaults，我才开始研究它，以便可以将它用于我的SwiftUI应用程序，但是我看到的所有示例都是针对UIKit的，当我尝试在SwiftUI中实现它们时，我遇到了很多问题错误）。

Answer 1

从Xcode 12.0（iOS 14.0）开始，可以对以下类型使用@AppStorage属性包装器：Bool, Int, Double, String, URL和Data。这是存储字符串值的用法示例：

struct ContentView: View {
    
    static let userNameKey = "user_name"
    
    @AppStorage(Self.userNameKey) var userName: String = "Unnamed"
    
    var body: some View {
        VStack {
            Text(userName)
            
            Button("Change automatically ") {
                userName = "Ivor"
            }
            
            Button("Change manually") {
                UserDefaults.standard.setValue("John", forKey: Self.userNameKey)
            }
        }
    }
}

在这里，您要声明具有默认值的userName属性，该属性不会传递给UserDefaults本身。首次对其进行突变时，应用程序会将该值写入UserDefaults，并使用新值自动更新视图。

如果需要，可以通过UserDefaults参数设置自定义store提供程序，如下所示：

@AppStorage(Self.userNameKey, store: UserDefaults.shared) var userName: String = "Mike"

和

extension UserDefaults {
    static var shared: UserDefaults {
        let combined = UserDefaults.standard
        combined.addSuite(named: "group.myapp.app")
        return combined
    }
}

注意：如果该值将在应用程序外部更改（例如，手动打开plist文件并更改值），View将不会收到该更新。

P.S。在View上也有新的扩展名，它添加了func defaultAppStorage(_ store: UserDefaults) -> some View，可以更改视图的存储空间。如果有许多@AppStorage属性，并且为每个属性设置自定义存储很麻烦，那么这会很有帮助。

Answer 2

下面的代码改编了this video中的Mohammad Azam的出色解决方案：

import SwiftUI

struct ContentView: View {
    @ObservedObject var userDefaultsManager = UserDefaultsManager()

    var body: some View {
        VStack {
            Toggle(isOn: self.$userDefaultsManager.firstToggle) {
                Text("First Toggle")
            }

            Toggle(isOn: self.$userDefaultsManager.secondToggle) {
                Text("Second Toggle")
            }
        }
    }
}

class UserDefaultsManager: ObservableObject {
    @Published var firstToggle: Bool = UserDefaults.standard.bool(forKey: "firstToggle") {
        didSet { UserDefaults.standard.set(self.firstToggle, forKey: "firstToggle") }
    }

    @Published var secondToggle: Bool = UserDefaults.standard.bool(forKey: "secondToggle") {
        didSet { UserDefaults.standard.set(self.secondToggle, forKey: "secondToggle") }
    }
}

Answer 3

首先，创建一个属性包装器，使我们可以轻松地在Settings类和UserDefaults之间建立链接：

import Foundation

@propertyWrapper
struct UserDefault<Value: Codable> {    
    let key: String
    let defaultValue: Value

    var value: Value {
        get {
            let data = UserDefaults.standard.data(forKey: key)
            let value = data.flatMap { try? JSONDecoder().decode(Value.self, from: $0) }
            return value ?? defaultValue
        }
        set {
            let data = try? JSONEncoder().encode(newValue)
            UserDefaults.standard.set(data, forKey: key)
        }
    }
}

然后，创建一个保存您的设置的数据存储：

import Combine
import SwiftUI

final class DataStore: BindableObject {
    let didChange = PassthroughSubject<DataStore, Never>()

    @UserDefault(key: "Settings", defaultValue: [])
    var settings: [Settings] {
        didSet {
            didChange.send(self)
        }
    }
}

现在，在您的视图中，访问您的设置：

import SwiftUI

struct SettingsView : View {
    @EnvironmentObject var dataStore: DataStore

    var body: some View {
        Toggle(isOn: $settings.space) {
            Text("\(settings.space)")
        }
    }
}

Answer 4

如果您要保留一个一次性结构，以至于属性包装器过于强大，则可以将其编码为JSON。解码时，将空Data实例用于无数据情况。

final class UserData: ObservableObject {
    @Published var profile: Profile? = try? JSONDecoder().decode(Profile.self, from: UserDefaults.standard.data(forKey: "profile") ?? Data()) {
        didSet { UserDefaults.standard.set(try? JSONEncoder().encode(profile), forKey: "profile") }
    }
}

Answer 5

另一个很好的解决方案是使用 @propertyWrapper 的非官方静态下标 API 而不是 wrappedValue，这大大简化了代码。定义如下：

@propertyWrapper
struct UserDefault<Value> {
    let key: String
    let defaultValue: Value

    init(wrappedValue: Value, _ key: String) {
        self.key = key
        self.defaultValue = wrappedValue
    }

    var wrappedValue: Value {
        get { fatalError("Called wrappedValue getter") }
        set { fatalError("Called wrappedValue setter") }
    }

    static subscript(
        _enclosingInstance instance: Preferences,
        wrapped wrappedKeyPath: ReferenceWritableKeyPath<Preferences, Value>,
        storage storageKeyPath: ReferenceWritableKeyPath<Preferences, Self>
    ) -> Value {
        get {
            let wrapper = instance[keyPath: storageKeyPath]
            return instance.userDefaults.value(forKey: wrapper.key) as? Value ?? wrapper.defaultValue
        }

        set {
            instance.objectWillChange.send()
            let key = instance[keyPath: storageKeyPath].key
            instance.userDefaults.set(newValue, forKey: key)
        }
    }
}

然后你可以像这样定义你的设置对象：

final class Settings: ObservableObject {
  let userDefaults: UserDefaults

  init(defaults: UserDefaults = .standard) {
    userDefaults = defaults
  }

  @UserDefaults("yourKey") var yourSetting: SettingType
  ...
}

但是，要小心这种实现。用户倾向于将他们的所有应用程序设置放在一个这样的对象中，并在依赖于一个设置的每个视图中使用它。这可能会因许多视图中过多的不必要的 objectWillChange 通知而导致速度变慢。您绝对应该通过在许多小班级中分解您的设置来分离关注点。

@AppStorage 是一个很好的原生解决方案，但缺点是它打破了唯一的真实来源范式，因为您必须为每个属性提供一个默认值。

Answer 6

caram的方法通常是可以的，但是代码存在很多问题，SmushyTaco无法使其正常工作。在下面，您将找到一个“开箱即用”的工作解决方案。

// 1. UserDefaults propertyWrapper

import Foundation

@propertyWrapper
struct UserDefault<T> {
    let key: String
    let defaultValue: T

    init(_ key: String, defaultValue: T) {
        self.key = key
        self.defaultValue = defaultValue
    }

    var wrappedValue: T {
        get {
            return UserDefaults.standard.object(forKey: key) as? T ?? defaultValue
        }
        set {
            UserDefaults.standard.set(newValue, forKey: key)
        }
    }
}

// 2. UserSettings类

final class UserSettings: BindableObject {
    let didChange = PassthroughSubject<Void, Never>()

    @UserDefault("ShowOnStart", defaultValue: false)
    var showOnStart: Bool {
        didSet {
            didChange.send()
        }
    }
}

// 3. SwiftUI视图

struct SettingsView : View {
    @ObjectBinding var settings = UserSettings()

    var body: some View {
        VStack {
            Toggle(isOn: $settings.showOnStart) {
                Text("Show welcome text")
            }
            if settings.showOnStart{
                Text("Welcome")
            }
        }
    }
}

如何在SwiftUI中使用UserDefaults？

6 个答案: