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: [String : String] = ["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"]

Existe-t-il un moyen dans Swift d'obtenir de jolis dictionnaires imprimés où chaque paire clé-valeur occupe une nouvelle ligne?

Vous pouvez utiliser dump , par exemple, si l'objectif est d'inspecter le dictionnaire. dumpfait partie de la bibliothèque standard de Swift.

Usage:

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

dump(dictionary)

Production:

dump imprime le contenu d'un objet par réflexion (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 attributes = ["foo": 10, "bar": 33, "baz": 42]
dump(attributes)

Impressions:

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

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

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

Il existe d'autres paramètres disponibles, comme namedéfinir une étiquette pour l'objet inspecté:

dump(attributes, name: "mirroring")

Impressions:

▿ mise en miroir: 3 paires clé / valeur
▿ [0]: (2 éléments)
- .0: bar
- .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 maxItems:, d'analyser l'objet jusqu'à une certaine profondeur avec maxDepth:et de modifier l'indentation des objets imprimés avec indent:.

Casting d'un dictionnaire en '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 de vidage, mais notez qu'elle ne vous donnera pas le nombre total de paires valeur / clé.

solution po

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

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

Juste une autre façon d'utiliser la programmation fonctionnelle

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

Production

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

À des fins de débogage uniquement, je convertirais le tableau ou le dictionnaire en un joli json 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 console:

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

Je ne considérerais pas une grande partie des réponses fournies ici comme de vrais JSON imprimés, car lorsque vous transmettez les résultats à un validateur JSON, le résultat est invalide (souvent en raison du code comprenant '=' plutôt que ':').

Le moyen le plus simple que j'ai trouvé de faire cela consiste simplement à convertir l'objet JSON en données à l'aide de l'option d'écriture jolie imprimée, puis à imprimer une chaîne en utilisant les données résultantes.

Voici un exemple:

let jsonData = try! JSONSerialization.data(withJSONObject: parameters, options: .prettyPrinted)

if let jsonString = String(data: jsonData, encoding: .utf8) {
    print(jsonString)
}

Résultat:

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

EDIT : Il a été souligné que l'OP n'a pas demandé JSON, mais je trouve que les réponses qui recommandent simplement d'imprimer ou de transférer les données dans la console fournissent très peu de formatage (le cas échéant) et ne sont donc pas assez imprimables.

Je crois que bien que l'OP ne demande pas JSON, c'est une réponse viable car il s'agit d'un format de données beaucoup plus lisible que le format horrible qui est craché dans la console par xcode / swift.

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: CustomDebugStringConvertible, Value:CustomDebugStringConvertible {

    var prettyprint : String {
        for (key,value) in self {
            print("\(key) = \(value)")
        }

        return self.description
    }
}

Autre application:

extension Dictionary where Key: CustomDebugStringConvertible, Value:CustomDebugStringConvertible {

    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

La méthodologie de conversion du dictionnaire Swift en json et inversement est la plus soignée. J'utilise 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 manière beaucoup plus propre de faire ce qui a déjà été suggéré. PS Pour l'instant, vous devrez convertir dict en 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 restriction.

MISE À JOUR: Mon PR a été accepté. Vous pouvez maintenant utiliser la commande psjson au lieu de pjson mentionné ci-dessus.

Pour Swift 3 (et en vous appuyant sur la brillante réponse de @Jalakoo ), créez l' Dictionaryextension suivante :

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

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

print(dictionary!.prettyPrint)

Détails

• Xcode 10.2.1 (10E1001), Swift 5

Solution

extension Dictionary {
    func format(options: JSONSerialization.WritingOptions) -> Any? {
        do {
            let jsonData = try JSONSerialization.data(withJSONObject: self, options: options)
            return try JSONSerialization.jsonObject(with: jsonData, options: [.allowFragments])
        } catch {
            print(error.localizedDescription)
            return nil
        }
    }
}

Usage

let dictionary: [String : Any] = [
                                    "id": 0,
                                    "bool": true,
                                    "int_array": [1,3,5],
                                    "dict_array": [
                                        ["id": 1, "text": "text1"],
                                        ["id": 1, "text": "text2"]
                                    ]
                                 ]
print("Regualr print:\n\(dictionary)\n")
guard let formatedDictionary = dictionary.format(options: [.prettyPrinted, .sortedKeys]) else { return }
print("Pretty printed:\n\(formatedDictionary)\n")

Résultats

Ajusté en fonction de mon autre réponse ici .

Solution JSON PrettyPrint utilisant l'alias LLDB

✨ Aucun code nécessaire ✨

• Pour obtenir un bon formatage json (indentations, retours à la ligne, etc.) vous pouvez définir un alias lldb en exécutant cette commande dans votre terminal lldb ( source ):

command regex pjson 's/(.+)/expr print(NSString(string: String(data: try! JSONSerialization.data(withJSONObject: %1, options: .prettyPrinted), encoding: .utf8)!))/'

• Vous ne souhaitez probablement pas redéfinir l'alias à chaque fois que vous ouvrez XCode, alors exécutez la commande suivante pour ajouter la définition d'alias à ~/.lldbinit:

echo "command regex pjson 's/(.+)/expr print(NSString(string: String(data: try! JSONSerialization.data(withJSONObject: %1, options: .prettyPrinted), encoding: .utf8)!))/'" >> ~/.lldbinit

• Cela créera l' pjsonalias que vous pouvez utiliser dans votre terminal lldb dans XCode:

pjson object

Comparaison des sorties pour l'objet Swift suivant:

// Using Any? to demo optional & arbitrary Type
let dictionary: Any? = [
    "embedded": [
        "JustForTheSakeOfTheDemo": 42
    ],
    "A" : "alfa",
    "B" : "bravo",
    "C" : "charlie",
    "D" : "delta",
    "E" : "echo",
    "F" : "foxtrot"
]

✅ Sortie de pjson dictionary

{
  "F" : "foxtrot",
  "D" : "delta",
  "embedded" : {
    "JustForTheSakeOfTheDemo" : 42
  },
  "E" : "echo",
  "A" : "alfa",
  "C" : "charlie",
  "B" : "bravo"
}

❌ Sortie de p dictionary

(Any?) $R0 = 7 key/value pairs {
  [0] = {
    key = "F"
    value = "foxtrot"
  }
  [1] = {
    key = "D"
    value = "delta"
  }
  [2] = {
    key = "embedded"
    value = 1 key/value pair {
      [0] = (key = "JustForTheSakeOfTheDemo", value = 42)
    }
  }
  [3] = {
    key = "E"
    value = "echo"
  }
  [4] = {
    key = "A"
    value = "alfa"
  }
  [5] = {
    key = "C"
    value = "charlie"
  }
  [6] = {
    key = "B"
    value = "bravo"
  }
}

❌ Sortie de p (dictionary as! NSDictionary)

(NSDictionary) $R18 = 0x0000000281e89710 {
  ObjectiveC.NSObject = {
    base__SwiftNativeNSDictionaryBase@0 = {
      baseNSDictionary@0 = {
        NSObject = {
          isa = Swift._SwiftDeferredNSDictionary<Swift.String, Any> with unmangled suffix "$"
        }
      }
    }
  }
}

❌ Sortie de po dictionary

▿ Optional<Any>
  ▿ some : 7 elements
    ▿ 0 : 2 elements
      - key : "F"
      - value : "foxtrot"
    ▿ 1 : 2 elements
      - key : "D"
      - value : "delta"
    ▿ 2 : 2 elements
      - key : "embedded"
      ▿ value : 1 element
        ▿ 0 : 2 elements
          - key : "JustForTheSakeOfTheDemo"
          - value : 42
    ▿ 3 : 2 elements
      - key : "E"
      - value : "echo"
    ▿ 4 : 2 elements
      - key : "A"
      - value : "alfa"
    ▿ 5 : 2 elements
      - key : "C"
      - value : "charlie"
    ▿ 6 : 2 elements
      - key : "B"
      - value : "bravo"

❌ Sortie de po print(dictionary)

Optional(["F": "foxtrot", "D": "delta", "embedded": ["JustForTheSakeOfTheDemo": 42], "E": "echo", "A": "alfa", "C": "charlie", "B": "bravo"])

swift 5, xcode 10.3:

po print(<your Plist container>)

Lors du débogage, affichez la structure conforme au protocole codable sur la console en
utilisant le format json.

extension Encodable {
    var jsonData: Data? {
        let encoder = JSONEncoder()
        encoder.outputFormatting = .prettyPrinted
        return try? encoder.encode(self)
    }
}

extension Encodable where Self: CustomDebugStringConvertible {
    var debugDescription: String {
         if let data = self.jsonData,
             let string = String(data: data, encoding: .utf8) {
             return string
         }
         return "can not convert to json string"
     }
}

Strcut conforme CustomDebugStringConvertible

struct Test: Codable, CustomDebugStringConvertible {
    let a: String
    let b: Int
}

let t = Test(a: "test string", b: 30)

debug print struct

(lldb) p print(t)
{
  "a" : "test string",
  "b" : 30
}

Jolie impression à partir de l'objet de données:

let jsonObj = try JSONSerialization.jsonObject(with: data, options: [])
            let jsonData = try JSONSerialization.data(withJSONObject: jsonObj, options: [.prettyPrinted])
            print(String(data: jsonData, encoding: .utf8)!)

Que diriez-vous:

import Foundation

extension Dictionary {
    var myDesc: String {
        get {
            var v = ""
            for (key, value) in self {
                v += ("\(key) = \(value)\n")
            }
            return v
        }
    }
}


// Then, later, for any dictionary:
print(dictionary.myDesc)

extension String {

    var conslePrintString: String {

        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 string = propertyList as? String else {
            return self
        }

        return string.replacingOccurrences(of: "\\r\\n", with: "\n")
    }
}

let code in extension String and it works fine 

let string = "\(jsonDictionary)".conslePrintString