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є частиною стандартної бібліотеки Свіфта.

Використання:

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: бар
- .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: бар
- .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)")

Мені це легше прочитати, ніж варіант дампа, але зауважте, що загальна кількість ключів-значень не дасть вам.

po рішення

Для тих, хто хоче бачити словник як 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

Тільки для налагодження я б перетворив масив або словник на досить надрукований 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"
    }
}

РЕДАГУВАТИ : було зазначено, що ОП не просив 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 Dictionary в json і назад є найоптимальнішою. Я використовую долото Facebook, яке має команду pjson, щоб надрукувати словник Swift. Наприклад:

(lldb) pjson dict as NSDictionary

Це має досить роздрукувати словник. Це набагато чистіший спосіб зробити те, що вже було запропоновано. PS На даний момент вам доведеться кидати dict як NSD Dictionary, оскільки середовище виконання Objective-C не розуміє словників Swift. Я вже підняв PR на зубилі, щоб позбутися цього обмеження.

ОНОВЛЕННЯ: Мій 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")

Результати

Коригується на основі моєї іншої відповіді тут .

Рішення PrettyPrint JSON із використанням псевдоніма LLDB

✨ Код не потрібен ✨

• Щоб отримати гарне форматування 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псевдонім, який ви можете використовувати у своєму терміналі lldb у XCode:

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

Вихідні дані pjson dictionary

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

Вихідні дані 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"
  }
}

Вихідні дані p (dictionary as! NSDictionary)

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

Вихідні дані 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"

Вихідні дані 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>)

Під час налагодження виведіть структуру, яка відповідає протоколу Codable, на консолі у
форматі 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 відповідає 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