How to Save and Load Data Using UserDefaults in SwiftUI

In SwiftUI, UserDefaults (formerly known as NSUserDefaults in UIKit) is a persistent storage system for storing user-specific data. It allows you to save small pieces of data, like settings, user preferences, or simple app states. Understanding how to use UserDefaults effectively is essential for creating apps that remember user choices between sessions. This comprehensive guide will show you how to save and load data using UserDefaults in SwiftUI, covering different data types and best practices.

What is UserDefaults?

UserDefaults is a class that provides a programmatic interface for interacting with the user’s defaults database. It’s designed to store and retrieve key-value pairs where keys are strings, and values are primitive data types like integers, floats, booleans, and strings, as well as some other foundation objects like dates, arrays, and dictionaries.

Why Use UserDefaults?

• Persistence: Data saved in UserDefaults persists across app launches.
• Simplicity: Easy to use for small datasets.
• User-Specific: Data is stored on a per-user basis.

How to Save and Load Data Using UserDefaults in SwiftUI

Step 1: Setting Up the Environment

No specific setup is needed beyond having a standard SwiftUI project. Ensure you have Xcode installed and a SwiftUI project ready.

Step 2: Saving Data to UserDefaults

You can save various data types using methods like set(_:forKey:). Here’s how to save data for different types:

Saving a String

import SwiftUI

struct ContentView: View {
    @State private var inputText: String = ""

    var body: some View {
        VStack {
            TextField("Enter text", text: $inputText)
                .padding()
                .onChange(of: inputText) { newValue in
                    UserDefaults.standard.set(newValue, forKey: "savedText")
                }

            Text("Saved Text: (UserDefaults.standard.string(forKey: "savedText") ?? "No text saved")")
                .padding()
        }
        .onAppear {
            inputText = UserDefaults.standard.string(forKey: "savedText") ?? ""
        }
    }
}

Explanation:

• We bind the TextField to a @State variable inputText.
• The onChange modifier listens for changes to the text field and saves the new value to UserDefaults with the key “savedText”.
• A Text view displays the saved text, retrieved from UserDefaults.
• The onAppear modifier retrieves the saved text when the view appears, populating the TextField with the previous value.

Saving an Integer

import SwiftUI

struct ContentView: View {
    @State private var counter: Int = 0

    var body: some View {
        VStack {
            Text("Counter: (counter)")
                .padding()

            Button("Increment") {
                counter += 1
                UserDefaults.standard.set(counter, forKey: "counterValue")
            }
            .padding()
        }
        .onAppear {
            counter = UserDefaults.standard.integer(forKey: "counterValue")
        }
    }
}

Explanation:

• A counter is maintained using a @State variable.
• The Button increments the counter and saves it to UserDefaults.
• UserDefaults.standard.integer(forKey:) is used to load the saved integer when the view appears.

Saving a Boolean

import SwiftUI

struct ContentView: View {
    @State private var isEnabled: Bool = false

    var body: some View {
        VStack {
            Toggle(isOn: $isEnabled) {
                Text("Enable Feature")
            }
            .padding()
            .onChange(of: isEnabled) { newValue in
                UserDefaults.standard.set(newValue, forKey: "isFeatureEnabled")
            }
        }
        .onAppear {
            isEnabled = UserDefaults.standard.bool(forKey: "isFeatureEnabled")
        }
    }
}

Explanation:

• A Toggle control is bound to a boolean state.
• The onChange modifier saves the boolean value to UserDefaults.
• UserDefaults.standard.bool(forKey:) loads the saved boolean when the view appears.

Saving an Array

import SwiftUI

struct ContentView: View {
    @State private var items: [String] = []
    @State private var newItem: String = ""

    var body: some View {
        VStack {
            List {
                ForEach(items, id: .self) { item in
                    Text(item)
                }
            }

            TextField("Add item", text: $newItem)
                .padding()
                .onSubmit {
                    addItem()
                }

            Button("Add Item") {
                addItem()
            }
            .padding()
        }
        .onAppear {
            if let savedItems = UserDefaults.standard.array(forKey: "itemList") as? [String] {
                items = savedItems
            }
        }
    }

    private func addItem() {
        items.append(newItem)
        UserDefaults.standard.set(items, forKey: "itemList")
        newItem = ""
    }
}

Explanation:

• An array of strings is managed.
• New items can be added via a text field and a button.
• The set(_:forKey:) method is used to save the array. Note that UserDefaults automatically handles converting arrays to a plist-compatible format.
• When loading, the data must be cast back to the correct type ([String]).

Saving a Dictionary

import SwiftUI

struct ContentView: View {
    @State private var profile: [String: String] = [:]
    @State private var name: String = ""
    @State private var email: String = ""

    var body: some View {
        VStack {
            TextField("Name", text: $name)
                .padding()
                .onChange(of: name) { newValue in
                    updateProfile()
                }

            TextField("Email", text: $email)
                .padding()
                .onChange(of: email) { newValue in
                    updateProfile()
                }

            Text("Name: (profile["name"] ?? "N/A")")
            Text("Email: (profile["email"] ?? "N/A")")
        }
        .padding()
        .onAppear {
            if let savedProfile = UserDefaults.standard.dictionary(forKey: "userProfile") as? [String: String] {
                profile = savedProfile
                name = profile["name"] ?? ""
                email = profile["email"] ?? ""
            }
        }
    }

    private func updateProfile() {
        profile = ["name": name, "email": email]
        UserDefaults.standard.set(profile, forKey: "userProfile")
    }
}

Explanation:

• A dictionary of string key-value pairs is stored.
• TextField values are bound to name and email.
• The dictionary is updated and saved in UserDefaults.
• Loading requires casting the dictionary to the appropriate type.

Step 3: Loading Data from UserDefaults

Use the corresponding getter methods like string(forKey:), integer(forKey:), bool(forKey:), array(forKey:), and dictionary(forKey:) to retrieve data.

let savedText = UserDefaults.standard.string(forKey: "savedText") ?? "Default Text"
let counterValue = UserDefaults.standard.integer(forKey: "counterValue")
let isFeatureEnabled = UserDefaults.standard.bool(forKey: "isFeatureEnabled")

if let savedItems = UserDefaults.standard.array(forKey: "itemList") as? [String] {
    // Use the saved array
}

if let savedProfile = UserDefaults.standard.dictionary(forKey: "userProfile") as? [String: String] {
    // Use the saved dictionary
}

Best Practices for Using UserDefaults

• Use Descriptive Keys: Choose meaningful keys to avoid confusion.
• Handle Defaults: Always provide default values using the nil-coalescing operator (??) when retrieving data.
• Avoid Storing Large Data: UserDefaults is not designed for storing large datasets. Consider using Core Data, Realm, or file storage for more significant data.
• Observe Changes: You can observe changes to UserDefaults by using UserDefaults.didChangeNotification for real-time updates.

import Combine

class SettingsObserver: ObservableObject {
    @Published var userName: String = UserDefaults.standard.string(forKey: "userName") ?? ""

    private var cancellables = Set()

    init() {
        NotificationCenter.default.publisher(for: UserDefaults.didChangeNotification)
            .sink { _ in
                self.userName = UserDefaults.standard.string(forKey: "userName") ?? ""
            }
            .store(in: &cancellables)
    }
}

Example of Combining UserDefaults with @AppStorage

SwiftUI introduces @AppStorage, which simplifies binding UserDefaults values to UI elements. Here’s how to use it:

import SwiftUI

struct ContentView: View {
    @AppStorage("userName") private var userName: String = ""
    @State private var inputText: String = ""

    var body: some View {
        VStack {
            TextField("Enter your name", text: $inputText)
                .padding()
                .onChange(of: inputText) { newValue in
                    userName = newValue
                }

            Text("Hello, (userName)!")
                .padding()
        }
        .onAppear {
            inputText = userName
        }
    }
}

Explanation:

• The @AppStorage("userName") property wrapper automatically saves and loads the userName string to UserDefaults.
• Any changes to the inputText in the TextField will automatically be saved, and loaded when the app restarts.

Conclusion

UserDefaults is a convenient tool for saving and loading small amounts of data in SwiftUI. By understanding how to save and load different data types, using best practices, and considering the alternative @AppStorage, you can create apps that provide a seamless, personalized user experience. Always remember to use UserDefaults appropriately and consider other storage options for larger or more complex data requirements.