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

在控制台上打印出以下内容：

{
    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)

在控制台上打印出以下内容：

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

在Swift中，有没有一种方法可以将其带到漂亮的印刷字典中，其中每个键值对都占一行？

例如，如果目标是检查字典，则可以使用dump。dump是Swift标准库的一部分。

用法：

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

dump(dictionary)

输出：

dump 通过反射（镜像）打印对象的内容。

数组的详细视图：

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

印刷品：

▿4个元素
-[0]：乔
-[1]：简
-[2]：吉姆
-[3]：乔伊斯

对于字典：

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

印刷品：

▿3个键/值对
▿[0]：（2个元素）
-. 0 ：bar
-.1：
33▿[1]：（2个元素）
-.0：baz
-.1：
42▿[2]：（ 2个元素）
-.0：foo
-.1：10

dump声明为dump(_:name:indent:maxDepth:maxItems:)。

第一个参数没有标签。

还有其他可用参数，例如name为要检查的对象设置标签：

dump(attributes, name: "mirroring")

印刷品：

▿镜像：3个键/值对
▿[0] ：（ 2个元素）
-. 0 ：bar
-.1：
33▿[1] ：（ 2个元素）
-.0：baz
-.1：
42▿[2] ：（2个元素）
-.0：foo
-.1：10

您也可以选择仅使用来打印特定数量的项目maxItems:，使用来解析对象达一定深度maxDepth:，并使用来更改打印对象的压痕indent:。

对我来说，将字典强制转换为“ AnyObject”是最简单的解决方案：

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

对我来说，这比转储选项更容易阅读，但是请注意，它不会为您提供键值的总数。

溶液

对于那些想要在控制台中看到没有转义序列的Dictionary为JSON的人，这是一种简单的方法

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

使用函数式编程的另一种方式

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

输出量

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

仅出于调试目的，我会将Array或Dictionary转换为漂亮打印的json：

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 "{}"
        }
    }
}

然后：

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

在控制台上的结果：

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

我不会考虑这里提供的许多答案，因为它们是真正漂亮的打印JSON，因为当您将结果传递到JSON验证程序中时，结果是无效的（通常是由于代码包括“ =”而不是“：”）。

我发现最简单的方法就是使用漂亮的打印选项将JSON对象转换为数据，然后使用结果数据打印字符串。

这是一个例子：

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

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

结果：

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

编辑：有人指出OP并没有要求提供JSON，但是我发现建议仅将数据打印或转储到控制台中的答案提供的格式化很少（如果有的话），因此打印效果不佳。

我相信，尽管OP不要求提供JSON，但它是一个可行的答案，因为与xcode / swift散布到控制台中的可怕格式相比，它是一种更具可读性的数据格式。

您可以只使用for循环并打印每次迭代

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

扩展应用：

extension Dictionary where Key: CustomDebugStringConvertible, Value:CustomDebugStringConvertible {

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

        return self.description
    }
}

备用应用程序：

extension Dictionary where Key: CustomDebugStringConvertible, Value:CustomDebugStringConvertible {

    func prettyPrint(){
        for (key,value) in self {
            print("\(key) = \(value)")
        }
    }
}

用法：

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

输出（在Xcode 8 beta 2 Playground中测试）：

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

将Swift字典转换为json并返回的方法是最干净的。我使用Facebook的凿子，该凿子具有pjson命令来打印Swift字典。例如：

(lldb) pjson dict as NSDictionary

这应该漂亮地打印字典。这是一种已经建议的更清洁的方法。PS目前，您必须将dict转换为NSDictionary，因为Objective-C运行时无法理解Swift字典。我已经提出了凿子的公关以摆脱该限制。

更新：我的PR被接受了。现在，您可以使用psjson命令而不是上面提到的pjson。

对于Swift 3（并以@Jalakoo的出色回答为基础），进行以下Dictionary扩展：

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

然后使用此方法以一种漂亮的方式（优于）打印任何层次的字典：dump()

print(dictionary!.prettyPrint)

细节

• Xcode 10.2.1（10E1001），Swift 5

解

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
        }
    }
}

用法

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")

结果

根据我在这里的其他答案进行了调整。

使用LLDB别名的PrettyPrint JSON解决方案

✨无需代码✨

• 要获得不错的json格式（缩进，换行符等），您可以通过在lldb终端（源）中运行以下命令来定义lldb别名：

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

• 您可能不想每次打开XCode时都重新定义别名，因此运行以下命令将别名定义附加到~/.lldbinit：

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

• 这将创建pjson别名，您可以在XCode的lldb终端中使用该别名：

pjson object

比较以下Swift对象的输出：

// 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"
]

of输出 pjson dictionary

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

of输出 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"
  }
}

of输出 p (dictionary as! NSDictionary)

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

of输出 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"

of输出 po print(dictionary)

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

迅速5，xcode 10.3：

po print(<your Plist container>)

调试时，
使用json格式将符合Codable Protocol的结构输出到控制台。

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符合CustomDebugStringConvertible

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

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

调试打印结构

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

从数据对象漂亮打印：

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

怎么样：

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