0
votes

Comment enregistrer les données JSON dans UserDefault dans Swift?

J'ai fait une demande de publication en utilisant Alamofire. Voici mon code pour récupérer les données du serveur en utilisant un point de terminaison:

{
  "accessToken" : "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6NTIsInJvbGUiOjEsImlhdCI6MTYwMzg2ODUxNCwiZXhwIjoxNjAzOTU0OTE0fQ.y68w8XQfqFZDVgaxiuFuVCOqaI5e5vZ-SfoDB_Ctxro",
  "role" : "admin",
   "auth" : true
}

Et voici les données que je reçois du serveur:

    Alamofire.request("http://192.168.80.21:3204/api/auth/signin", method: .post, parameters: parameters,encoding: JSONEncoding.default, headers: nil).responseJSON {
        response in
        switch response.result {
        case .success(let value):
            let json = JSON(value)
            print(json)

            break
        case .failure(let error):
            print("Error :- \(error)")
        }
    }
}

Je souhaite enregistrer la réponse dans UserDefault pour une utilisation ultérieure. Aidez-moi à enregistrer les données dans Userdefault et à récupérer et imprimer les données.

ios swift

0 commentaires

4 Réponses :

0
votes

Si vous utilisez une variable globale. Vous pouvez utiliser la méthode de save fonction de votre objectif qui est écrit ci-dessous:

let objects = [yourObjectClass]()

        func save() {
            let jsonEncoder = JSONEncoder()
            if let savedData = try? jsonEncoder.encode(objects) { 
                let defaults = UserDefaults.standard    
                defaults.set(savedData, forKey: "objects") 
            } else {
                print("Failed to save objects.")
            }
        }
    }

0 commentaires

0
votes

jeton d'accès

 let data = getFromDefault(key: "userData", type: AuthUser.self)
 print(data)

Vous pouvez utiliser la fonction ci-dessus. comme ci-dessous.

struct AuthUser : Codable {

  let accessToken : String?
  let role: String?
  let auth: Bool?

  enum CodingKeys: String, CodingKey {
    case accessToken = "accessToken"
    case role = "role"
    case auth = "auth"
  }

  init(from decoder: Decoder) throws {
    let values = try decoder.container(keyedBy: CodingKeys.self)
    accessToken = try values.decodeIfPresent(String.self, forKey: .accessToken)
    role = try values.decodeIfPresent(String.self, forKey: .role)
    auth = try values.decodeIfPresent(Bool.self, forKey: .auth)
  }
}

Ici,

Param: les data sont un paramètre générique de type T Vous devez donc ici transmettre les données de réponse que vous obtenez du serveur. (Il doit être de type classe Codable )

Param: AuthUser est

setInDefault(key: "userData", type: AuthUser.self, data: data)

Pour obtenir des données:

func setInDefault<T: Codable>(key: String, type: T.Type, data: T?) {
    
    guard let data = data else {
        return
    }

    do {
        let encoder = JSONEncoder()
        let encodeData = try encoder.encode(data)
        let dict:[String:Any] = try JSONSerialization.jsonObject(with: encodeData, options: .allowFragments) as! [String : Any]
        
        let data = NSKeyedArchiver.archivedData(withRootObject: dict)

        //set user data in defaults
        UserDefaults.standard.set(data, forKey: key)
        UserDefaults.standard.synchronize()
    } catch {
        print(error)
        //handle error
    }
}

func getFromDefault<T: Codable>(key: String, type: T.Type) -> T? {

    let archieved = UserDefaults.standard.value(forKey: key)
    let dict = NSKeyedUnarchiver.unarchiveObject(with: archieved as? Data ?? Data())
    let decoder = JSONDecoder()
    do {
        if let dic = dict {
            let data = try JSONSerialization.data(withJSONObject: dic, options: .prettyPrinted)
            return try decoder.decode(type, from: data)
        }
        
    } catch {
        print(error)
         //handle error
    }
    return nil
}

3 commentaires

Param: les données sont les données à stocker. pouvez-vous s'il vous plaît effacer ceci

Veuillez vérifier la réponse modifiée.

Notez que le paramètre de type n'est pas nécessaire dans la plupart des cas et au moins vous pouvez utiliser un type: T.Type = T.self valeur par défaut type: T.Type = T.self .

-1
votes

Vous pouvez enregistrer les données du modèle JSON dans Userdefaults en utilisant le code de fonction ci-dessous

func getData() -> yourModelData {
        var userDefaults = UserDefaults.standard
        let decoded  = userDefaults.data(forKey: "yourKey")
        let decodedData = NSKeyedUnarchiver.unarchiveObject(with: decoded) as! [yourModelData]
        return decodedData
    }

et récupérer les données des défauts de l'utilisateur utilisent cette fonction

 func saveData(data: yourModelData){
        var userDefaults = UserDefaults.standard
        let encodedData: Data = NSKeyedArchiver.archivedData(withRootObject: yourModelData)
        userDefaults.set(encodedData, forKey: "yourKey")
        userDefaults.synchronize()
        
    }

0 commentaires

1
votes

Créer un modèle, une structure conforme à Codable

let auth = UserDefaults.standard.auth(forKey: "Auth")

et étendre UserDefaults

Alamofire.request("http://192.168.80.21:3204/api/auth/signin", method: .post, parameters: parameters).responseData {
    response in
    switch response.result {
    case .success(let data):
        do { 
            let auth = try JSONDecoder().decode(Auth.self, from: data)
            print(auth)
            UserDefaults.standard.set(auth, forKey: "Auth")
        } catch { print(error) }

    case .failure(let error):
        print("Error :- \(error)")
    }
}

Vous pouvez maintenant utiliser auth(forKey:) et set(_:forKey:) pour lire et écrire directement une instance Auth .

Déposez SwiftyJSON et changez la partie Alamofire pour décoder le JSON dans la structure avec JSONDecoder

extension UserDefaults {
    func auth(forKey defaultName: String) -> Auth? {
        guard let data = data(forKey: defaultName) else { return nil }
        do {
            return try JSONDecoder().decode(Auth.self, from: data)
        } catch { print(error); return nil }
    }

    func set(_ value: Auth, forKey defaultName: String) {
        let data = try? JSONEncoder().encode(value)
        set(data, forKey: defaultName)
    }
}

Pour lire l'instance, écrivez

struct Auth: Codable {
    let accessToken, role: String
    let auth: Bool
}

0 commentaires