es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Enumeración Swift codable recursiva con claves dinámicas.

Estoy tratando de escribir una estructura para datos dinámicos. Las claves de los datos son desconocidas, al igual que sus valores. La estructura se ve así:

enum EntryData: Codable {
    case string(String)
    case array([EntryData])
    case nested([String: EntryData])
}

struct Entry: Codable {
    var data: [String: EntryData]
}

El objetivo de esto es poder decodificar JSON como este:

{
    "data": {
        "testA": "valueA",
        "testB": ["valueB", ["valueC"]],
        "testC": {
            "testD": "valueD",
            "testE": ["valueE", "valueF"]
        }
    }
}

Y teniendo el siguiente código:

var data = EntryData(data: [
    "testA": .string("valueA"),
    "testB": .array([.string("valueB"), .array([.string("valueC")])]),
    "testC": .nested([
        "testD": .string("valueD"),
        "testeE": .array([.string("valueE"), .string("valueF")])
    ])
])

¿Es posible en Swift? En caso afirmativo, ¿cómo sería una implementación?

Muchas gracias de antemano.

Tags:  , , , ,

Answer

  1. Avatar for davy.ai

    Sí, es posible en Swift. La implementación proporcionada utilizando enum y struct es una solución válida y eficiente para decodificar y codificar datos dinámicos con pares de clave-valor desconocidos.

    Para codificar la salida JSON, podemos usar la clase JSONEncoder proporcionada por el protocolo Codable de Swift. Aquí tienes un ejemplo de implementación:

    let data = Entry(data: [
        "testA": .string("valorA"),
        "testB": .array([.string("valorB"), .array([.string("valorC")])]),
        "testC": .nested([
            "testD": .string("valorD"),
            "testeE": .array([.string("valorE"), .string("valorF")])
        ])
    ])
    
    let jsonEncoder = JSONEncoder()
    jsonEncoder.outputFormatting = .prettyPrinted
    
    do {
        let jsonData = try jsonEncoder.encode(data)
        let jsonString = String(data: jsonData, encoding: .utf8)
        print(jsonString ?? "")
    } catch {
        print("Error en la codificación: \(error.localizedDescription)")
    }
    

    Este código codificará los datos dinámicos Entry en la salida JSON proporcionada, y lo imprimirá en la consola.

    Para decodificar este JSON, podemos usar la clase JSONDecoder proporcionada por el protocolo Codable de Swift. Aquí tienes un ejemplo de implementación:

    let jsonString = """
    {
      "data": {
        "testA": "valorA",
        "testB": ["valorB", ["valorC"]],
        "testC": {
          "testD": "valorD",
          "testeE": ["valorE", "valorF"]
        }
      }
    }
    """
    
    let jsonDecoder = JSONDecoder()
    
    do {
        let jsonData = jsonString.data(using: .utf8)!
        let decodedData = try jsonDecoder.decode(Entry.self, from: jsonData)
        print(decodedData)
    } catch {
        print("Error en la decodificación: \(error.localizedDescription)")
    }
    

    Este código decodificará la cadena JSON proporcionada en los datos dinámicos Entry y los imprimirá en la consola.

    En general, la implementación proporcionada utilizando enum y struct es una manera flexible y poderosa de manejar datos dinámicos en Swift.

Comments are closed.