Nsryjdtyk

SWIFT 3

Casting a dictionary to 'AnyObject' was the simplest solution for me:

    let dictionary = ["a":"b",

                      "c":"d",

                      "e":"f"]

    print("This is the console output: (dictionary as AnyObject)")

This is easier to read for me than the dump option, but note it won't give you the total number of key-values.

po solution

For those of you want to see Dictionary as JSON with out escape sequence in console, here is a simple way to do that

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

Just another way using Functional Programming

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

Output

B: bravo

A: alfa

F: foxtrot

C: charlie

D: delta

E: echo

For debug purpose only I convert the Array or Dictionary to a pretty printed json:

public extension Collection {



    /// Convert self to JSON String.

    /// - Returns: Returns the JSON as String or empty string if error while parsing.

    func json() -> String {

        do {

            let jsonData = try JSONSerialization.data(withJSONObject: self, options: [.prettyPrinted])

            guard let jsonString = String(data: jsonData, encoding: String.Encoding.utf8) else {

                print("Can't create string with data.")

                return "{}"

            }

            return jsonString

        } catch let parseError {

            print("json serialization error: (parseError)")

            return "{}"

        }

    }

}

Then:

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

Result on console:

HTTP request: https://example.com/get-data

Params: {

  "lon" : 10.8663676,

  "radius" : 111131.8046875,

  "lat" : 23.8063882,

  "index_start" : 0,

  "uid" : 1

}

I wouldn't consider a lot of the answers provided here true pretty printed JSON, as when you pass the results into a JSON validator the result is invalid (often due to the code including '=' rather than ':').

The easiest way I've found of doing this is just converting the JSON object to data using the pretty printed writing option then printing a string using the resulting data.

Here is an example:

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



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

        print(jsonString)

    }

Result:

{

    "jsonData": [

        "Some String"

    ],

    "moreJSONData": "Another String",

    "evenMoreJSONData": {

        "A final String": "awd"

    }

}

EDIT: It's been pointed out that the OP did not ask for JSON, however I find that the answers that recommend just printing or dumping the data into the console provide very little formatting (if any) and are therefore not pretty printing.

I believe that despite the OP not asking for JSON, it is a viable answer as it is a much more readable format for data than the horrendous format that is spat out into the console by xcode/swift.

You can just use a for loop and print each iteration

for (key,value) in dictionary { 

    print("(key) = (value)")

}

Application in extension:

extension Dictionary where Key: CustomDebugStringConvertible, Value:CustomDebugStringConvertible {



    var prettyprint : String {

        for (key,value) in self {

            print("(key) = (value)")

        }



        return self.description

    }

}

Alternate 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

Output (Tested in Xcode 8 beta 2 Playground):

A = alfa

B = bravo

C = charlie

D = delta

E = echo

F = foxtrot

For Swift 3 (& building on the brilliant answer by @Jalakoo), make the following Dictionary extension:

extension Dictionary where Key: ExpressibleByStringLiteral, Value: Any {

    var prettyPrint: String {

        return String(describing: self as AnyObject)

    }

}

then print a dictionary of any hierarchy in a pretty way (better than dump()) using this:

print(dictionary!.prettyPrint)

The methodology of converting the Swift Dictionary to json and back is the neatest. I usually use Facebook's chisel which has a pjson command to print a Swift dictionary.
Eg:

(lldb) pjson dict as NSDictionary

This should pretty-print the dictionary. This is a much cleaner way to do what has already been suggested.
P.S.
For now, you'll have to cast dict as NSDictionary because Objective-C runtime doesn't understand Swift dictionaries. I have already raised a PR on chisel to get rid of that restriction.

How about:

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