Existe-t-il un moyen d'imprimer joliment les dictionnaires Swift sur la console ?

Question

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

affiche ce qui suit sur la console :

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

---

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

affiche ce qui suit sur la console :

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

Existe-t-il un moyen en Swift de lui faire imprimer des dictionnaires où chaque paire clé-valeur occupe une nouvelle ligne ?

Answer 1

L'attribution d'un dictionnaire à 'AnyObject' était la solution la plus simple pour moi :

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

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

Answer 2

solution po

Pour ceux d'entre vous qui veulent voir le dictionnaire en JSON sans la séquence d'échappement dans console Voici un moyen simple de le faire

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

Mise à jour

Vérifiez aussi cette réponse Réponse :

Answer 3

Vous pourriez utiliser déverser par exemple, si le but est d'inspecter le dictionnaire. dump fait partie de la bibliothèque standard de Swift.

Utilisation :

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

dump(dictionary)

Sortie :

---

dump imprime le contenu d'un objet par réflexion (mirroring).

Vue détaillée d'un tableau :

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

Imprimés :

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

Pour un dictionnaire :

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

Imprimés :

3 paires clé/valeur
[0] : (2 éléments)
- .0 : barre
- .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 paramètres disponibles, comme name pour définir une étiquette pour l'objet inspecté :

dump(attributes, name: "mirroring")

Imprimés :

la mise en miroir : 3 paires clé/valeur
[0] : (2 éléments)
- .0 : barre
- .1 : 33
[1] : (2 éléments)
- .0 : baz
- .1 : 42
[2] : (2 éléments)
- .0 : foo
- .1 : 10

Vous pouvez également choisir de n'imprimer qu'un certain nombre d'éléments avec la fonction maxItems: pour analyser l'objet jusqu'à une certaine profondeur à l'aide de la fonction maxDepth: et pour changer l'indentation des objets imprimés avec indent: .

Answer 4

A des fins de débogage uniquement, je convertirais le tableau ou le dictionnaire en un json joliment imprimé :

public extension Collection {

    /// Convert self to JSON String.
    /// Returns: the pretty printed JSON string or an empty string if any error occur.
    func json() -> String {
        do {
            let jsonData = try JSONSerialization.data(withJSONObject: self, options: [.prettyPrinted])
            return String(data: jsonData, encoding: .utf8) ?? "{}"
        } catch {
            print("json serialization error: \(error)")
            return "{}"
        }
    }
}

Ensuite :

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
}

Answer 5

Une autre façon d'utiliser la programmation fonctionnelle

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

Sortie

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