Est-il possible d’imprimer des dictionnaires Swift sur la console?

NSDictionary *dictionary = @{@"A" : @"alfa", @"B" : @"bravo", @"C" : @"charlie", @"D" : @"delta", @"E" : @"echo", @"F" : @"foxtrot"}; NSLog(@"%@", dictionary.description); 

imprime ce qui suit sur la console:

 { A = alfa; B = bravo; C = charlie; D = delta; E = echo; F = foxtrot; } 

 let dictionary: [Ssortingng : Ssortingng] = ["A" : "alfa", "B" : "bravo", "C" : "charlie", "D" : "delta", "E" : "echo", "F" : "foxtrot"]; print(dictionary) 

imprime ce qui suit sur la console:

 ["B": "bravo", "A": "alfa", "F": "foxtrot", "C": "charlie", "D": "delta", "E": "echo"] 

Y a-t-il un moyen dans Swift de le faire pour imprimer de jolis dictionnaires où chaque paire clé-valeur occupe une nouvelle ligne?

Vous pouvez utiliser dump , par exemple, si le but est d’inspecter le dictionnaire. dump fait partie de la bibliothèque standard de Swift.

Usage:

 let dictionary: [Ssortingng : Ssortingng] = ["A" : "alfa", "B" : "bravo", "C" : "charlie", "D" : "delta", "E" : "echo", "F" : "foxtrot"] dump(dictionary) 

Sortie:

entrer la description de l'image ici


dump imprime le contenu d’un object par reflection (mise en miroir).

Vue détaillée d’un tableau:

 let names = ["Joe", "Jane", "Jim", "Joyce"] dump(names) 

Impressions:

▿ 4 éléments
– [0]: Joe
– [1]: Jane
– [2]: Jim
– [3]: Joyce

Pour un dictionnaire:

 let atsortingbutes = ["foo": 10, "bar": 33, "baz": 42] dump(atsortingbutes) 

Impressions:

Pairs 3 paires clé / valeur
▿ [0]: (2 éléments)
– .0: bar
– 0,1: 33
▿ [1]: (2 éléments)
– .0: baz
– .1: 42
▿ [2]: (2 éléments)
– .0: foo
– .1: 10

dump est déclaré comme dump(_:name:indent:maxDepth:maxItems:) .

Le premier paramètre n’a pas d’étiquette.

Il y a d’autres parameters disponibles, comme name pour définir une étiquette pour l’object inspecté:

 dump(atsortingbutes, name: "mirroring") 

Impressions:

▿ miroir: 3 paires clé / valeur
▿ [0]: (2 éléments)
– .0: bar
– 0,1: 33
▿ [1]: (2 éléments)
– .0: baz
– .1: 42
▿ [2]: (2 éléments)
– .0: foo
– .1: 10

Vous pouvez également choisir d’imprimer uniquement un certain nombre d’éléments avec maxItems: pour parsingr l’object jusqu’à une certaine profondeur avec maxDepth: et pour modifier l’indentation des objects imprimés avec un indent: maxDepth:

SWIFT 3

Convertir un dictionnaire en ‘AnyObject’ est la solution la plus simple pour moi:

  let dictionary = ["a":"b", "c":"d", "e":"f"] print("This is the console output: \(dictionary as AnyObject)") 

entrer la description de l'image ici

C’est plus facile à lire pour moi que l’option de sauvegarde, mais notez que cela ne vous donnera pas le nombre total de valeurs-clés.

Juste une autre façon d’utiliser la functional programming

 dictionary.forEach { print("\($0): \($1)") } 

Sortie

 B: bravo A: alfa F: foxtrot C: charlie D: delta E: echo 

solution po

Pour ceux d’entre vous qui veulent voir Dictionary en JSON sans séquence d’échappement dans la console , voici un moyen simple de le faire

(lldb) po print(Ssortingng(data: try! JSONSerialization.data(withJSONObject: object, options: .prettyPrinted), encoding: .utf8 )!)

Pour le débogage seulement, je convertis le tableau ou le dictionnaire en json bien imprimé:

 public extension Collection { /// Convert self to JSON Ssortingng. /// - Returns: Returns the JSON as Ssortingng or empty ssortingng if error while parsing. func json() -> Ssortingng { do { let jsonData = try JSONSerialization.data(withJSONObject: self, options: [.prettyPrinted]) guard let jsonSsortingng = Ssortingng(data: jsonData, encoding: Ssortingng.Encoding.utf8) else { print("Can't create ssortingng with data.") return "{}" } return jsonSsortingng } catch let parseError { print("json serialization error: \(parseError)") return "{}" } } } 

Alors:

 print("\nHTTP request: \(URL)\nParams: \(params.json())\n") 

Résultat sur la console:

 HTTP request: https://example.com/get-data Params: { "lon" : 10.8663676, "radius" : 111131.8046875, "lat" : 23.8063882, "index_start" : 0, "uid" : 1 } 

Vous pouvez simplement utiliser une boucle for et imprimer chaque itération

 for (key,value) in dictionary { print("\(key) = \(value)") } 

Application en extension:

 extension Dictionary where Key: CustomDebugSsortingngConvertible, Value:CustomDebugSsortingngConvertible { var prettyprint : Ssortingng { for (key,value) in self { print("\(key) = \(value)") } return self.description } } 

Autre application:

 extension Dictionary where Key: CustomDebugSsortingngConvertible, Value:CustomDebugSsortingngConvertible { func prettyPrint(){ for (key,value) in self { print("\(key) = \(value)") } } } 

Usage:

 dictionary.prettyprint //var prettyprint dictionary.prettyPrint //func prettyPrint 

Sortie (Testé dans Xcode 8 beta 2 Playground):

 A = alfa B = bravo C = charlie D = delta E = echo F = foxtrot 

Pour Swift 3 (et en s’appuyant sur la shinye réponse de @Jalakoo ), effectuez l’extension Dictionary suivante:

 extension Dictionary where Key: ExpressibleBySsortingngLiteral, Value: Any { var prettyPrint: Ssortingng { return Ssortingng(describing: self as AnyObject) } } 

puis imprimez un dictionnaire de n’importe quelle hiérarchie d’une manière assez précise (mieux que dump() ) en utilisant ceci:

 print(dictionary!.prettyPrint) 

La méthode de conversion du dictionnaire Swift en json et back est la plus nette. J’utilise généralement le ciseau de Facebook qui a une commande pjson pour imprimer un dictionnaire Swift. Par exemple:

 (lldb) pjson dict as NSDictionary 

Cela devrait bien imprimer le dictionnaire. C’est une façon beaucoup plus propre de faire ce qui a déjà été suggéré. PS Pour l’instant, vous devrez lancer dict comme NSDictionary car le runtime Objective-C ne comprend pas les dictionnaires Swift. J’ai déjà soulevé un PR sur le ciseau pour me débarrasser de cette ressortingction.

Je ne considérerais pas beaucoup de réponses fournies ici comme un JSON bien imprimé, car lorsque vous transmettez les résultats dans un validateur JSON, le résultat est invalide (souvent à cause du code incluant ‘=’ plutôt que ‘:’).

La manière la plus simple de le faire est de convertir l’object JSON en données en utilisant l’option d’écriture plutôt imprimée, puis d’imprimer une chaîne à l’aide des données obtenues.

Voici un exemple:

  let jsonData = try! JSONSerialization.data(withJSONObject: parameters, options: .prettyPrinted) if let jsonSsortingng = Ssortingng(data: jsonData, encoding: .utf8) { print(jsonSsortingng) } 

Résultat:

 { "jsonData": [ "Some Ssortingng" ], "moreJSONData": "Another Ssortingng", "evenMoreJSONData": { "A final Ssortingng": "awd" } } 

Que diriez-vous:

 import Foundation extension Dictionary { var myDesc: Ssortingng { get { var v = "" for (key, value) in self { v += ("\(key) = \(value)\n") } return v } } } // Then, later, for any dictionary: print(dictionary.myDesc) 
 extension Ssortingng { var conslePrintSsortingng: Ssortingng { guard let data = "\"" .appending( replacingOccurrences(of: "\\u", with: "\\U") .replacingOccurrences(of: "\"", with: "\\\"") ) .appending("\"") .data(using: .utf8) else { return self } guard let propertyList = try? PropertyListSerialization.propertyList(from: data, options: [], format: nil) else { return self } guard let ssortingng = propertyList as? Ssortingng else { return self } return ssortingng.replacingOccurrences(of: "\\r\\n", with: "\n") } } let code in extension Ssortingng and it works fine let ssortingng = "\(jsonDictionary)".conslePrintSsortingng