Swift saving and retrieving custom object from UserDefaults

let age = aDecoder.decodeObject(forKey: "age") as! Int

This has been changed for Swift 3; this no longer works for value types. The correct syntax is now:

let age = aDecoder.decodeInteger(forKey: "age")

There are associated decode...() functions for various different types:

let myBool = aDecoder.decodeBoolean(forKey: "myStoredBool")
let myFloat = aDecoder.decodeFloat(forKey: "myStoredFloat")

Edit: Full list of all possible decodeXXX functions in Swift 3

Edit:

Another important note: If you have previously saved data that was encoded with an older version of Swift, those values must be decoded using decodeObject(), however once you re-encode the data using encode(...) it can no longer be decoded with decodeObject() if it's a value type. Therefore Markus Wyss's answer will allow you to handle the case where the data was encoded using either Swift version:

self.age = aDecoder.decodeObject(forKey: "age") as? Int ?? aDecoder.decodeInteger(forKey: "age")

In Swift 4:

You can use Codable to save and retrieve custom object from the Userdefaults. If you're doing it frequently then you can add as extension and use it like below.

extension UserDefaults {

   func save<T:Encodable>(customObject object: T, inKey key: String) {
       let encoder = JSONEncoder()
       if let encoded = try? encoder.encode(object) {
           self.set(encoded, forKey: key)
       }
   }

   func retrieve<T:Decodable>(object type:T.Type, fromKey key: String) -> T? {
       if let data = self.data(forKey: key) {
           let decoder = JSONDecoder()
           if let object = try? decoder.decode(type, from: data) {
               return object
           }else {
               print("Couldnt decode object")
               return nil
           }
       }else {
           print("Couldnt find key")
           return nil
       }
   }

}

Your Class must follow Codable. Its just a typealias for both Encodable & Decodable Protocol.

class UpdateProfile: Codable {
  //Your stuffs
}

Usage:

let updateProfile = UpdateProfile()

//To save the object
UserDefaults.standard.save(customObject: updateProfile, inKey: "YourKey")

//To retrieve the saved object
let obj = UserDefaults.standard.retrieve(object: UpdateProfile.self, fromKey: "YourKey")

For more Encoding and Decoding Custom types, Please go through the Apple's documentation.

Update: Swift 5 New Solution

Testable UserDefaults with Property Wrapper + Combine

@propertyWrapper struct UserDefaultsStore<T: Codable> {
    let key: String
    let storage: UserDefaultsStorage
    private let subject: PassthroughSubject<[T], Never> = .init()
    
    var wrappedValue: [T] {
        get {
            guard let data = storage.object(forKey: key) as? Data,
               let models = try? JSONDecoder().decode([T].self, from: data) else {
                return []
            }
            return models
           
        }
        set {
            if let encoded = try? JSONEncoder().encode(newValue) {
                storage.set(encoded, forKey: key)
                subject.send(wrappedValue)
            }
            
        }
    }
    
    var projectedValue: AnyPublisher<[T], Never> {
        return subject.eraseToAnyPublisher()
    }
}

protocol UserDefaultsStorage {
    func object(forKey key: String) -> Any?
    func set(_ value: Any?, forKey key: String)
}

extension UserDefaults: UserDefaultsStorage {}

struct DataToSave: Codable {}



//Usage
// Main Target
enum StorageSettings {
    @UserDefaultsStore<DataToSave>(key:"stored_data", storage: DIInjecter.userDefaults)
    static var storeSomething: [DataToSave]
    
}
struct DependenciesInjecter {
    lazy var userDefaults: UserDefaultsStorage = UserDefaults.standard
}
var DIInjecter = DependenciesInjecter()

// Test Target
class UserDefaultsStorageMock: UserDefaultsStorage {
    var values: [String: Any]
    init(values: [String : Any] = [:]) {
        self.values = values
    }

    func object(forKey key: String) -> Any? {
        return values[key]
    }

    func set(_ value: Any?, forKey key: String) {
        values[key] = value
    }
}

extension DependenciesInjecter {
    static var mock: DependenciesInjecter {
        Self(userDefaults: UserDefaultsStorageMock())
    }
}
// Put it in setup func
DIInjecter = .mock

Try this:

self.age = aDecoder.decodeObject(forKey: "age") as? Int ?? aDecoder.decodeInteger(forKey: "age")

In Swift 5, I would use a property wrapper to simply the code:

/// A type that adds an interface to use the user’s defaults with codable types
///
/// Example:
/// ```
/// @UserDefaultCodable(key: "nameKey", defaultValue: "Root") var name: String
/// ```
/// Adding the attribute @UserDefaultCodable the property works reading and writing from user's defaults
/// with any codable type
///
@propertyWrapper public struct UserDefaultCodable<T: Codable> {
    private let key: String
    private let defaultValue: T

    /// Initialize the key and the default value.
    public init(key: String, defaultValue: T) {
        self.key = key
        self.defaultValue = defaultValue
    }

    public var wrappedValue: T {
        get {
            // Read value from UserDefaults
            guard let data = UserDefaults.standard.object(forKey: key) as? Data else {
                // Return defaultValue when no data in UserDefaults
                return defaultValue
            }

            // Convert data to the desire data type
            let value = try? JSONDecoder().decode(T.self, from: data)
            return value ?? defaultValue
        }
        set {
            // Convert newValue to data
            let data = try? JSONEncoder().encode(newValue)

            // Set value to UserDefaults
            UserDefaults.standard.set(data, forKey: key)
        }
    }
}