Verificar la longitud de un array JSON sin deserializarlo.

06 Aug, 2023 Programación 0

Tengo una solicitud que es un cuerpo JSON en forma de una matriz de objetos, algo como esto:

{
    "data": [
        {
            "id": "1234",
            "someNestedObject": {
                "someBool": true,
                "randomNumber": 488
            },
            "timestamp": "2021-12-13T02:43:44.155Z"
        },
        {
            "id": "4321",
            "someNestedObject": {
                "someBool": false,
                "randomNumber": 484
            },
            "timestamp": "2018-11-13T02:43:44.155Z"
        }
    ]
}

Quiero obtener un recuento de los objetos en la matriz y dividirlos en salidas JSON separadas para pasar al siguiente servicio. Actualmente, estoy haciendo esto deserializando el cuerpo JSON de la solicitud original y luego recorriendo los elementos serializando cada uno nuevamente y adjuntándolo al mensaje saliente. Algo como esto:

requestBodyBytes := []byte(JSON_INPUT_STRING)

type body struct {
    Foo []json.RawMessage `json:"foo"`
}

var inputs body

_ = json.Unmarshal(requestBodyBytes, &inputs)

for _, input := range inputs.Foo {
    re, _ := json.Marshal(input)

    // ... hacer algo con re
}

Lo que estoy viendo es que el arreglo de bytes antes y después es diferente, aunque la representación en cadena es la misma. Me pregunto si hay alguna manera de hacer esto sin alterar la codificación o lo que sea que esté sucediendo aquí para cambiar los bytes y protegerme contra mutaciones no deseadas. Los objetos JSON reales en la matriz tendrán formas diferentes, por lo que no puedo usar una definición JSON estructurada con validaciones de campos para ayudar.

Además, el código anterior es solo un ejemplo de lo que está sucediendo, por lo tanto, si hay errores de ortografía o sintaxis, ignórelos, ya que el código real funciona según se describe.

type request struct { Data []json.RawMessage `json:"data"` } func parseJSONRequest(jsonData []byte) ([]json.RawMessage, error) { var req request err := json.Unmarshal(jsonData, &req) if err != nil { // manejar el error } return req.Data, nil } func processJSONArray(jsonData []byte) error { data, err := parseJSONRequest(jsonData) if err != nil { // manejar el error } for _, rawMsg := range data { newObj := struct { Object json.RawMessage `json:"object"` }{rawMsg} newBlob, err := json.Marshal(newObj) if err != nil { // manejar el error } // hacer algo con newBlob } return nil }

Answer

davy.ai

August 6, 2023 at 6:32 am
Como modelo de lenguaje de IA, no puedo ejecutar ni depurar código, pero puedo sugerir posibles soluciones para tu problema.

Una posible solución para evitar alterar la codificación o los bytes del array JSON original es crear un nuevo array JSON para cada objeto y luego serializarlo por separado. Aquí tienes el código sugerido:
```
type request struct {
    Data []json.RawMessage `json:"data"`
}

func parseJSONRequest(jsonData []byte) ([]json.RawMessage, error) {
    var req request
    err := json.Unmarshal(jsonData, &req)
    if err != nil {
        // manejar el error
    }
    return req.Data, nil
}

func processJSONArray(jsonData []byte) error {
    data, err := parseJSONRequest(jsonData)
    if err != nil {
        // manejar el error
    }
    for _, rawMsg := range data {
        newObj := struct {
            Object json.RawMessage `json:"object"`
        }{rawMsg}
        newBlob, err := json.Marshal(newObj)
        if err != nil {
            // manejar el error
        }
        // hacer algo con newBlob
    }
    return nil
}
```
El código anterior deserializará la solicitud JSON original (que contiene un array de objetos), extraerá el campo data y luego iterará sobre cada objeto en el array. Luego, creará un nuevo objeto JSON temporal que contenga el objeto extraído, lo serializará por separado y hará algo con él. Esto debería evitar cualquier mutación no deseada del array JSON original.

Ten en cuenta que este código se basa en el hecho de que la estructura de cada objeto en el array puede ser diferente. Si tienes requisitos estrictos para cada objeto, es posible que debas crear una estructura separada para cada tipo de objeto y deserializar cada objeto en su estructura correspondiente para asegurarte de que cada objeto sea válido.

Comments are closed.

es.davy.ai

¿Tienes una pregunta?

Verificar la longitud de un array JSON sin deserializarlo.

Answer

davy.ai