Wie kann ich UserDefaults verwenden, um Zeichenfolgen, Boolesche Werte und andere Daten in Swift zu speichern / abzurufen?

ref: NSUserdefault objectTypes

Swift 3 und höher

Geschäft

UserDefaults.standard.set(true, forKey: "Key") //Bool
UserDefaults.standard.set(1, forKey: "Key")  //Integer
UserDefaults.standard.set("TEST", forKey: "Key") //setObject

Abrufen

 UserDefaults.standard.bool(forKey: "Key")
 UserDefaults.standard.integer(forKey: "Key")
 UserDefaults.standard.string(forKey: "Key")

Entfernen

 UserDefaults.standard.removeObject(forKey: "Key")

Entfernen Sie alle Schlüssel

 if let appDomain = Bundle.main.bundleIdentifier {
UserDefaults.standard.removePersistentDomain(forName: appDomain)
 }

Swift 2 und darunter

Geschäft

NSUserDefaults.standardUserDefaults().setObject(newValue, forKey: "yourkey")
NSUserDefaults.standardUserDefaults().synchronize()

Abrufen

  var returnValue: [NSString]? = NSUserDefaults.standardUserDefaults().objectForKey("yourkey") as? [NSString]

Entfernen

 NSUserDefaults.standardUserDefaults().removeObjectForKey("yourkey")

registerDefaults: Fügt das Registrierungswörterbuch dem letzten Element in jeder Suchliste hinzu. Dies bedeutet, dass NSUserDefaults, nachdem es an jedem anderen gültigen Speicherort nach einem Wert gesucht hat, in registrierten Standardeinstellungen sucht, was sie als "Fallback" -Wert nützlich macht. Registrierte Standardeinstellungen werden niemals zwischen den Ausführungen einer Anwendung gespeichert und sind nur für die Anwendung sichtbar, die sie registriert.

Standardwerte aus Standardkonfigurationsdateien werden automatisch registriert.

Erkennen Sie beispielsweise die App vom Start an und erstellen Sie die Struktur zum Speichern des Starts

struct DetectLaunch {
static let keyforLaunch = "validateFirstlunch"
static var isFirst: Bool {
    get {
        return UserDefaults.standard.bool(forKey: keyforLaunch)
    }
    set {
        UserDefaults.standard.set(newValue, forKey: keyforLaunch)
    }
}
}

Registrieren Sie die Standardwerte beim Start der App:

UserDefaults.standard.register(defaults: [
        DetectLaunch.isFirst: true
    ])

Entfernen Sie den Wert bei Beendigung der App:

func applicationWillTerminate(_ application: UIApplication) {
    DetectLaunch.isFirst = false

}

und überprüfen Sie den Zustand als

if DetectLaunch.isFirst {
  // app launched from first
}

Name der UserDefaults-Suite

Ein weiterer Name für eine Eigenschaftssuite , der hauptsächlich für das App Groups-Konzept verwendet wird , das Beispielszenario, das ich hier übernommen habe :

Der Anwendungsfall ist, dass ich meine UserDefaults (eine andere Geschäftslogik erfordert möglicherweise, dass Userdefaults separat gruppiert werden müssen) durch einen Bezeichner wie die SharedPreferences von Android trennen möchte. Wenn ein Benutzer in meiner App beispielsweise auf die Schaltfläche zum Abmelden klickt, möchte ich seine kontobezogenen Standardeinstellungen löschen, jedoch nicht den Standort des Geräts.

let user = UserDefaults(suiteName:"User")

Bei Verwendung von userDefaults synchronize wurden die Detailinformationen in der doppelten Antwort hinzugefügt.

Beste Möglichkeit, UserDefaults zu verwenden

Schritte

1. Erstellen Sie eine Erweiterung von UserDefaults
2. Erstellen Sie eine Aufzählung mit den erforderlichen Schlüsseln, die lokal gespeichert werden sollen
3. Speichern und rufen Sie die lokalen Daten ab, wo immer Sie möchten

Stichprobe

extension UserDefaults{

    //MARK: Check Login
    func setLoggedIn(value: Bool) {
        set(value, forKey: UserDefaultsKeys.isLoggedIn.rawValue)
        //synchronize()
    }

    func isLoggedIn()-> Bool {
        return bool(forKey: UserDefaultsKeys.isLoggedIn.rawValue)
    }

    //MARK: Save User Data
    func setUserID(value: Int){
        set(value, forKey: UserDefaultsKeys.userID.rawValue)
        //synchronize()
    }

    //MARK: Retrieve User Data
    func getUserID() -> Int{
        return integer(forKey: UserDefaultsKeys.userID.rawValue)
    }
}

Aufzählung für Schlüssel zum Speichern von Daten

enum UserDefaultsKeys : String {
    case isLoggedIn
    case userID
}

Speichern Sie in UserDefaults, wo Sie möchten

UserDefaults.standard.setLoggedIn(value: true)          // String
UserDefaults.standard.setUserID(value: result.User.id!) // String

Daten überall in der App abrufen

print("ID : \(UserDefaults.standard.getUserID())")
UserDefaults.standard.getUserID()

Werte entfernen

UserDefaults.standard.removeObject(forKey: UserDefaultsKeys.userID) 

Auf diese Weise können Sie primitive Daten optimal speichern

Update Sie müssen synchronize () nicht verwenden, um die Werte zu speichern. Wie @Moritz darauf hinwies, war es unnötig und gab den Artikel darüber. Überprüfen Sie die Kommentare für weitere Details

Swift 4 :

Geschäft

    UserDefaults.standard.set(object/value, forKey: "key_name")

Wiederholen

    var returnValue: [datatype]? = UserDefaults.standard.object(forKey: "key_name") as? [datatype]

Entfernen

    UserDefaults.standard.removeObject(forKey:"key_name") 

//Save
NSUserDefaults.standardUserDefaults().setObject("yourString", forKey: "YourStringKey")

//retrive
let yourStr : AnyObject? = NSUserDefaults.standardUserDefaults().objectForKey("YourStringKey")

Sie können NSUserDefaultsauf diese Weise schnell verwenden,

@IBAction func writeButton(sender: UIButton)
{
    let defaults = NSUserDefaults.standardUserDefaults()
    defaults.setObject("defaultvalue", forKey: "userNameKey")

}

@IBAction func readButton(sender: UIButton)
{
    let defaults = NSUserDefaults.standardUserDefaults()
    let name = defaults.stringForKey("userNameKey")
    println(name) //Prints defaultvalue in console
}

Swift 5 und höher:

let defaults = UserDefaults.standard

defaults.set(25, forKey: "Age")
let savedInteger = defaults.integer(forKey: "Age")

defaults.set(true, forKey: "UseFaceID")
let savedBoolean = defaults.bool(forKey: "UseFaceID")

defaults.set(CGFloat.pi, forKey: "Pi")
defaults.set("Your Name", forKey: "Name")
defaults.set(Date(), forKey: "LastRun")


let array = ["Hello", "World"]
defaults.set(array, forKey: "SavedArray")


let savedArray = defaults.object(forKey: "SavedArray") as? [String] ?? [String()

let dict = ["Name": "Your", "Country": "YourCountry"]
defaults.set(dict, forKey: "SavedDict")

let savedDictionary = defaults.object(forKey: "SavedDictionary") as? [String: String] ?? [String: String]()

:) :)

Ich habe NSDictionary normal gespeichert und kann es korrekt abrufen.

 dictForaddress = placemark.addressDictionary! as NSDictionary
        let userDefaults = UserDefaults.standard
        userDefaults.set(dictForaddress, forKey:Constants.kAddressOfUser)

// Zum Abrufen von Daten aus NSDictionary.

let userDefaults = UserDefaults.standard
    let dictAddress = userDefaults.object(forKey: Constants.kAddressOfUser) as! NSDictionary

class UserDefaults_WorstPresidentName {
    static let key = "appname.worstPresidentName"

    static var value: String? {
        get {
            return UserDefaults.standard.string(forKey: key)
        }
        set {
            if newValue != nil {
                UserDefaults.standard.set(newValue, forKey: key)
            } else {
                UserDefaults.standard.removeObject(forKey: key)
            }
        }
    }
}

UserDefault + Helper.swift

import UIKit

private enum Defaults: String {
   case countryCode = "countryCode"
   case userloginId   = "userloginid"
}

final class UserDefaultHelper {

static var countryCode: String? {
    set{
        _set(value: newValue, key: .countryCode)
    } get {
        return _get(valueForKay: .countryCode) as? String ?? ""
    }
}

static var userloginId: String? {
    set{
        _set(value: newValue, key: .userloginId)
    } get {
        return _get(valueForKay: .userloginId) as? String ?? ""
    }
}

private static func _set(value: Any?, key: Defaults) {
    UserDefaults.standard.set(value, forKey: key.rawValue)
}

private static func _get(valueForKay key: Defaults)-> Any? {
    return UserDefaults.standard.value(forKey: key.rawValue)
}

static func deleteCountryCode() {
    UserDefaults.standard.removeObject(forKey: Defaults.countryCode.rawValue)
 }

static func deleteUserLoginId() {
    UserDefaults.standard.removeObject(forKey: Defaults.userloginId.rawValue)
 }
}

Verwendung:

Wert speichern:

UserDefaultHelper.userloginId = data["user_id"] as? String

Wert abrufen:

let userloginid = UserDefaultHelper.userloginId

Wert löschen:

UserDefaultHelper.deleteUserLoginId()

Ich würde Anbus Antwort sagen vollkommen in Ordnung, aber ich musste beim Abrufen von Einstellungen Schutz hinzufügen, damit mein Programm nicht fehlschlägt

Hier ist der aktualisierte Code-Snip in Swift 5

Speichern von Daten in UserDefaults

@IBAction func savePreferenceData(_ sender: Any) {
        print("Storing data..")
        UserDefaults.standard.set("RDC", forKey: "UserName") //String
        UserDefaults.standard.set("TestPass", forKey: "Passowrd")  //String
        UserDefaults.standard.set(21, forKey: "Age")  //Integer

    }

Abrufen von Daten aus UserDefaults

    @IBAction func fetchPreferenceData(_ sender: Any) {
        print("Fetching data..")

        //added guard
        guard let uName = UserDefaults.standard.string(forKey: "UserName") else { return }
        print("User Name is :"+uName)
        print(UserDefaults.standard.integer(forKey: "Age"))
    }

Legen Sie in der Klasse Aden Wert für den Schlüssel fest:

let text = "hai"  
UserDefaults.standard.setValue(text, forKey: "textValue")

In der Klasse B, erhalten den Wert für den Text mit der Taste , die in der Klasse deklariert Aund weisen Sie den entsprechenden Variable , die Sie brauchen:

var valueOfText  = UserDefaults.value(forKey: "textValue")

Swift 4, ich habe Enum für die Behandlung von UserDefaults verwendet.

Dies ist nur ein Beispielcode. Sie können es gemäß Ihren Anforderungen anpassen.

Zum Speichern, Abrufen, Entfernen. Auf diese Weise fügen Sie der Aufzählung einfach einen Schlüssel für Ihren UserDefaults-Schlüssel hinzu. Behandeln Sie Werte beim Abrufen und Speichern entsprechend dem Datentyp und Ihren Anforderungen.

enum UserDefaultsConstant : String {
    case AuthToken, FcmToken

    static let defaults = UserDefaults.standard


   //Store
    func setValue(value : Any) {
        switch self {
        case .AuthToken,.FcmToken:
            if let _ = value as? String {
                UserDefaults.standard.set(value, forKey: self.rawValue)
            }
            break
        }

        UserDefaults.standard.synchronize()
    }

   //Retrieve
    func getValue() -> Any? {
        switch self {
        case .AuthToken:
            if(UserDefaults.standard.value(forKey: UserDefaultsConstant.AuthToken.rawValue) != nil) {

                return "Bearer "+(UserDefaults.standard.value(forKey: UserDefaultsConstant.AuthToken.rawValue) as! String)
            }
            else {
                return ""
            }

        case .FcmToken:

            if(UserDefaults.standard.value(forKey: UserDefaultsConstant.FcmToken.rawValue) != nil) {
                print(UserDefaults.standard.value(forKey: UserDefaultsConstant.FcmToken.rawValue))
                return (UserDefaults.standard.value(forKey: UserDefaultsConstant.FcmToken.rawValue) as! String)
            }
            else {
                return ""
            }
        }
    }

    //Remove
    func removeValue() {
        UserDefaults.standard.removeObject(forKey: self.rawValue)
        UserDefaults.standard.synchronize()
    }
}

Zum Speichern eines Werts in Benutzerstandards,

if let authToken = resp.data?.token {
     UserDefaultsConstant.AuthToken.setValue(value: authToken)
    }

Zum Abrufen eines Werts aus den Benutzerstandards

//As AuthToken value is a string
    (UserDefaultsConstant.AuthToken.getValue() as! String)