Entendiendo la recursividad en JSONata

• Explicación

  • Definición de la función

  • Aplicación de la función

• Incrementando el Ejemplo

  • Ejemplo de JSON de entrada

  • Función expandida y consulta

  • Explicación

  • Ejemplo de salida

• Ejemplos adicionales y casos de uso

  • Ejemplo con elementos hermanos

  • JSON de entrada

  • Función expandida y consulta para tratar elementos hermanos

• Conclusión

Este artículo presenta un ejemplo que define recursividad para navegar y transformar una estructura JSON. Se detallará el ejemplo inicial y se expandirá con explicaciones adicionales, ejemplos prácticos y casos de uso, proporcionando una comprensión completa de la recursividad en JSONata

(
   $person := function($node) { $node.{"n": Name, "p":$person(Parent.Person)}};

   {
       "Person": Person ~> $person($)
   }
)

Explicación:

_{1. Definición de la Función:}

$person := function($node) { $node.{"n": Name, "p":$person(Parent.Person)}};

• La línea anterior define una función recursiva llamada $person. La función recibe un nodo ($node) como argumento y devuelve un objeto que contiene:

  • "n": Name – La propiedad Name del nodo actual.

  • "p": $person(Parent.Person) – El resultado de llamar a la función $person sobre la propiedad Parent.Person del nodo actual, lo que permite una navegación recursiva.

_{2. Aplicación de la Función:}

{
   "Person": Person ~> $person($)
}

Esta parte aplica la función $person al campo "Person" del contexto actual (denotado por $). El operador ~> canaliza el campo "Person" a través de la función $person.

---

Incrementando el Ejemplo

Mejoraremos el ejemplo añadiendo más campos para la transformación y navegando en estructuras JSON más profundamente anidadas. Considera la siguiente estructura JSON más compleja:

_{JSON de Entrada}

{
 "Person": {
   "Name": "João",
   "Age": 30,
   "Parent": {
     "Person": {
       "Name": "Maria",
       "Age": 55,
       "Parent": {
         "Person": {
           "Name": "Roberto",
           "Age": 80
         }
       }
     }
   }
 }
}

_{Función Expandida}

Modifiquemos la función para incluir la propiedad "Age" y manejar los casos en los que "Parent" pueda estar ausente.

(
   $person := function($node) {
       $node.{
           "n": Name,
           "a": Age,
           "p": $exists($person(Parent.Person)) ? $person(Parent.Person) : null
       }
   };

   {
       "Person": Person ~> $person($)
   }
)

_Explicación

• La función modificada ahora incluye "a": Age para capturar la edad de cada persona.

• El operador ternario ($exists($person(Parent.Person)) ? ... : null) garantiza que la función devuelva "null" si el nodo no está presente, evitando errores al navegar por la jerarquía.

Ejemplo de salida

Aplicar la consulta ampliada al ejemplo de entrada JSON dará como resultado:

{
  "Person": {
    "n": "João",
    "a": 30,
    "p": {
      "n": "Maria",
      "a": 55,
      "p": {
        "n": "Roberto",
        "a": 80,
        "p": null
      }
    }
  }
}

Ejemplos adicionales y casos de uso

_{Ejemplo con hermanos}

Consideremos un ejemplo en el que cada persona puede tener hermanos.

JSON de entrada

{
 "Person": {
   "Name": "João",
   "Age": 30,
   "Siblings": [
     {
       "Name": "Ana",
       "Age": 25
     },
     {
       "Name": "Alex",
       "Age": 28
     }
   ],
   "Parent": {
     "Person": {
       "Name": "Maria",
       "Age": 55,
       "Parent": {
         "Person": {
           "Name": "Roberto",
           "Age": 80
         }
       }
     }
   }
 }
}

Función ampliada y consulta para manejar hermanos

Podemos ampliar aún más nuestra función para incluir a los hermanos:

(
   $person := function($node) {
       $node.{
           "n": Name,
           "a": Age,
           "s": $exists($person(Siblings)) ? $person(Siblings) : null,
           "p": $exists($person(Parent.Person)) ? $person(Parent.Person) : null
       }
   };

   {
       "Person": Person ~> $person($)
   }
)

Explicación

La línea "s": $exists($person(Siblings)) ? $person(Siblings) : null mapea el arreglo Siblings y transforma a cada hermano en un objeto.

Ejemplo de salida

Aplicar la consulta ampliada al ejemplo de entrada JSON dará como resultado:

{
 "Person": {
   "n": "João",
   "a": 30,
   "s": [
     {
       "n": "Ana",
       "a": 25,
       "s": null,
       "p": null
     },
     {
       "n": "Alex",
       "a": 28,
       "s": null,
       "p": null
     }
   ],
   "p": {
     "n": "Maria",
     "a": 55,
     "s": null,
     "p": {
       "n": "Roberto",
       "a": 80,
       "s": null,
       "p": null
     }
   }
 }
}

---

Conclusión

La función recursiva en JSONata permite navegar y transformar estructuras JSON anidadas de forma poderosa. Con estas funciones, es posible recorrer jerarquías, manejar campos opcionales y mapear arrays para producir transformaciones complejas y automatizadas.