> For the complete documentation index, see [llms.txt](https://docs.skyone.cloud/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.skyone.cloud/espanol/skyone-studio/how-to/entendiendo-la-recursividad-en-jsonata.md).

# Entendiendo la recursividad en JSONata

* [Explicación](#explicacion)
  * [Definición de la función](#id-1.-definicion-de-la-funcion)
  * [Aplicación de la función](#id-2.-aplicacion-de-la-funcion)
* [Incrementando el Ejemplo](#incrementando-el-ejemplo)
  * [Ejemplo de JSON de entrada](#json-de-entrada)
  * [Función expandida y consulta](#funcion-expandida)
  * [Explicación](#explicacion-1)
  * [Ejemplo de salida](#ejemplo-de-salida)
* [Ejemplos adicionales y casos de uso](#ejemplos-adicionales-y-casos-de-uso)
  * [Ejemplo con elementos hermanos](#ejemplo-con-hermanos)
  * [JSON de entrada](#json-de-entrada)
  * [Función expandida y consulta para tratar elementos hermanos](#funcion-ampliada-y-consulta-para-manejar-hermanos)
* [Conclusión](#conclusion)

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

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

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

### **Explicación:**

#### <sub>**1. Definición de la Función:**</sub>

```jsonata
$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.

#### <sub>**2. Aplicación de la Función:**</sub>

```jsonata
{
   "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.&#x20;Considera la siguiente estructura JSON más compleja:

#### <sub>**JSON de Entrada**</sub>

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

#### <sub>**Función Expandida**</sub>

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

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

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

#### <sub>Explicación</sub>

* 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:

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

#### **Ejemplos adicionales y casos de uso**

#### <sub>**Ejemplo con hermanos**</sub>

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

**JSON de entrada**

```json
{
 "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:

```jsonata
(
   $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:

```json
{
 "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.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.skyone.cloud/espanol/skyone-studio/how-to/entendiendo-la-recursividad-en-jsonata.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
