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

imprime el siguiente en la consola:

{
    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 el siguiente en la consola:

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

Hay una manera rápida de conseguir a bastante impresión de diccionarios donde cada par clave-valor que ocupa una nueva línea?

  • Usted podría utilizar dump, por ejemplo, si el objetivo es inspeccionar el diccionario. stackoverflow.com/documentation/swift/3966/logging-in-swift/…
  • print(dictionary as! NSDictionary) cheap trick?
  • Realmente el dump() sugerencia debido a que no es necesario escribir ningún código o lanzarla. @EricAya, si publicas una respuesta con este comentario, voy a marcar como respuesta.
  • Hecho. He hecho una respuesta con un ejemplo de la salida.
InformationsquelleAutor Toland Hon | 2016-08-04

12 Comentarios

  1. 75

    Usted podría utilizar volcado, por ejemplo, si el objetivo es inspeccionar el diccionario. dump es parte de Swift de la biblioteca estándar.

    Uso:

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

    De salida:

    Es allí una manera bastante impresión Swift diccionarios a la consola?


    dump imprime el contenido de un objeto a través de la reflexión (reflejo).

    Vista detallada de una matriz:

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

    Imprime:

    ▿ 4 elementos

    – [0]: Joe

    – [1]: Jane

    – [2]: Jim

    – [3]: Joyce

    Para un diccionario:

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

    Imprime:

    ▿ 3 pares de clave/valor

    ▿ [0]: (2 elementos)

    – .0: bar

    – .1: 33

    ▿ [1]: (2 elementos)

    – .0: baz

    – .1: 42

    ▿ [2]: (2 elementos)

    – .0: foo

    – .1: 10

    dump se declara como dump(_:name:indent:maxDepth:maxItems:).

    El primer parámetro no tiene etiqueta.

    Hay otros parámetros disponibles, como name para establecer una etiqueta para el objeto que está siendo inspeccionado:

    dump(attributes, name: "mirroring")

    Imprime:

    ▿ de creación de reflejo: 3 pares de clave/valor

    ▿ [0]: (2 elementos)

    – .0: bar

    – .1: 33

    ▿ [1]: (2 elementos)

    – .0: baz

    – .1: 42

    ▿ [2]: (2 elementos)

    – .0: foo

    – .1: 10

    También puede elegir imprimir sólo un cierto número de elementos con maxItems:, para analizar el objeto hasta una cierta profundidad con maxDepth:, y para cambiar la sangría de los objetos impresos con indent:.

    • Esto no es bastante impreso JSON, este es solo el dumping de una variable dentro de la consola – no es válido JSON. Mientras se hace el traje OP necesidades creo que la pregunta debe cambiar la redacción para que coincida con este.
    • no es bastante impreso JSON Nadie dijo que era. El OP se le preguntó acerca bastante impresión Swift diccionarios – nadie está hablando de JSON, excepto un par de off-topic ms responden. El OP pregunta no es acerca de JSON a todos.
    • También por favor, no cambie la pregunta. Que sería vandalismo. La pregunta es clara, como es, y no se trata de JSON. No cambio una pregunta sólo porque algunas de las respuestas a hablar de otra cosa. Gracias.
  2. 73

    La fundición de un diccionario para ‘AnyObject’ fue la solución más simple para mí:

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

    Es allí una manera bastante impresión Swift diccionarios a la consola?

    Esto es más fácil de leer para que me de la opción de volcado, pero se nota que no le dará el número total de pares clave-valor.

    • Genial, pero no puedo entender por qué funciona.
    • Es una manera brillante y la manera mejor de volcado
    • Muy simple. Gracias!
    • Impresionante!! Justo lo que necesitaba.
  3. 65

    po solución

    Para aquellos de ustedes que quieren ver Diccionario como JSON con la secuencia de escape en consola, aquí está una manera simple de hacer que

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

    • Ya que es una expresión y no un objeto, debe ser ‘p’ y no ‘po’. Pero muchas gracias por esta solución. Funciona muy bien para mí
    • ¿importa? El comando parece hacer la misma cosa de cualquier manera.
    • Ahora tanto la forma de hacerlo está trabajando. Pero antes de hacer un pedido de impresión» no funcionó para mí. (po medios objeto de impresión…. que es un poco confuso si usted tiene una impresión después y no un objeto en mi humilde opinión)
    • muchas gracias por esto, esto es lo que yo necesitaba
  4. 32

    Sólo otra forma, el uso de la Programación Funcional

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

    Salida

    B: bravo
    A: alfa
    F: foxtrot
    C: charlie
    D: delta
    E: echo
    • Esta debe ser la respuesta. Funciona a la perfección!
    • O a ser «aún más funcional»… diccionario.mapa { «($0): ($1)» }.forEach(imprimir) (la lengua en la mejilla comentario)
    • Esto funciona para OP [String: String] diccionario, pero no es ideal para [AnyHashable: Any] diccionarios, donde si un valor es un diccionario, ya estás de vuelta de Swift no bastante impresión.
    • Tengo libro marcado esta respuesta🙂, porque todavía no recuerdo esta sintaxis 🙄
  5. 19

    Para depurar propósito sólo puedo convertir la Matriz o el Diccionario de una bonita impreso 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 "{}"
            }
        }
    }

    A continuación:

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

    Resultado en la consola:

    HTTP request: https://example.com/get-data
    Params: {
      "lon" : 10.8663676,
      "radius" : 111131.8046875,
      "lat" : 23.8063882,
      "index_start" : 0,
      "uid" : 1
    }
    • ¿qué es el bLog aquí ?
    • el bLog es un simple registro personalizado con la traza que escribí, editado con print().
  6. 9

    Yo no tener en cuenta muchas de las respuestas que se dieron aquí la verdadera bastante impreso JSON, como cuando se pasa de los resultados en JSON validador el resultado no es válido (a menudo debido a que el código incluido en el ‘=’ en lugar de ‘:’).

    La forma más sencilla que he encontrado de hacerlo es simplemente convertir el objeto JSON a los datos utilizando el bastante la escritura impresa opción, a continuación, imprimir una cadena con los datos resultantes.

    Aquí está un ejemplo:

    let jsonData = try! JSONSerialization.data(withJSONObject: parameters, options: .prettyPrinted)
    
    if let jsonString = String(data: jsonData, encoding: .utf8) {
        print(jsonString)
    }

    Resultado:

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

    EDITAR: Se ha señalado que el OP no pedir JSON, sin embargo me parece que las respuestas que recomiendo impresión o la descarga de los datos en la consola de proporcionar a muy poco de formato (si alguna) y por lo tanto no son bastante impresión.

    Creo que a pesar de que el OP no se pregunta por JSON, es una respuesta viable ya que es mucho más fácil de leer el formato de los datos que el horrendo formato que se escupió en la consola de xcode/swift.

    • Gracias, Con esto pude bastante imprimir en medio de la depuración a través de e let jsonData = try! JSONSerialization.data(withJSONObject: response, options: .prettyPrinted);if let jsonString = String(data: jsonData, encoding: .utf8) { print(jsonString) }
  7. 5

    Sólo se puede utilizar un bucle for y de impresión de cada iteración

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

    Aplicación en extensión:

    extension Dictionary where Key: CustomDebugStringConvertible, Value:CustomDebugStringConvertible {
    
        var prettyprint : String {
            for (key,value) in self {
                print("\(key) = \(value)")
            }
    
            return self.description
        }
    }

    Aplicación alternativa:

    extension Dictionary where Key: CustomDebugStringConvertible, Value:CustomDebugStringConvertible {
    
        func prettyPrint(){
            for (key,value) in self {
                print("\(key) = \(value)")
            }
        }
    }

    Uso:

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

    De salida (Probado en Xcode 8 beta 2 de Recreo):

    A = alfa
    B = bravo
    C = charlie
    D = delta
    E = echo
    F = foxtrot
    • Hay una razón por la que usted hizo prettyprint un var en lugar de sólo una función?
    • Honestamente, no creo que sea cuestión (puedo estar equivocado). Pero si lo usas mucho, entonces es menos escribir. Pero plantear una pregunta interesante.
    • Puesto que hay una description y debugDescription ya, que podría ser más apropiado para llamar a la var prettyDescription y de retorno de la cadena con formato.
  8. 4

    Para Swift 3 (& edificio en la brillante respuesta por @Jalakoo), realice los siguientes Dictionary extensión:

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

    a continuación, imprimir un diccionario de cualquier jerarquía en un bastante manera (mejor que dump()) el uso de este:

    print(dictionary!.prettyPrint)
  9. 2

    La metodología de conversión de la Swift Diccionario para json y la espalda es el más bonito. Normalmente yo uso Facebook del cincel que tiene un pjson comando para imprimir un Swift diccionario.
    Por ejemplo:

    (lldb) pjson dict as NSDictionary

    Este debe bastante-imprimir el diccionario. Esta es mucho más limpia de hacer lo que ya se ha sugerido.
    P. S.
    Por ahora, usted tiene que convertir dict como NSDictionary porque Objective-C en tiempo de ejecución no entiende Swift diccionarios. Ya he planteado una PR en el cincel para deshacerse de esa restricción.

  10. 1

    Detalles

    • Xcode 10.2.1 (10E1001), Swift 5

    Solución

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

    Uso

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

    Resultados

    Es allí una manera bastante impresión Swift diccionarios a la consola?

  11. 0

    Cómo sobre:

    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)
  12. 0
    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

Dejar respuesta

Please enter your comment!
Please enter your name here