Este post, traducido por SocialTIC, fue publicado originalmente en inglés en School of Data. Se trata de una contribución que Noah Veltman hizo para Learning Lunches, una serie de tutoriales que desmitifican la complejidad de las herramientas que son relevantes para los periodistas.

Casi todas las aplicaciones web nos proveen de datos en dos formatos: XML o JSON. Los dos pueden ser muy confusos, ya que son muy diferentes a lo que estás acostumbrado a ver, por ejemplo, en Excel. XML o JSON no son hojas de cálculo. Son flexibles y pueden representar casi cualquier tipo de datos.

Ambos pueden formar diferentes capas, así que puedes presentar los datos de manera muy compleja con muchos niveles. Por ejemplo, piensa en tu árbol familiar: al estar en XML o JSON, te permitiría no sólo mencionar a cada persona, sino también su relación con cada miembro de la familia. Las tablas bidimensionales (como las que usamos en Excel) no permiten fácilmente la creación de capas necesarias para información como la mencionada.

Nota: En los ejemplos, a continuación, separé con sangrías cada categoría solo para hacer más claro todo. Puedes deshacerlos y poner todos los comandos en una sola línea y esto no cambiará tus resultados. Generalmente cuando consigues datos de una aplicación, todo quedará como una sola línea continua. Esto es muy eficiente pero no es muy amable para el lector. Siempre lo puedes pasar a un formato más amigable como éste.

Lo básico sobre XML

Si alguna vez trabajaste con HTML, entonces te será fácil entender XML. Cada elemento tiene un nombre y consiste de una etiqueta de apertura y una de cierre (<nombre de etiqueta></nombre de etiqueta>). Todo lo que está entre estas etiquetas pertenece al elemento. Pero pronto podemos comenzar a hablar de padres, hijos y hermanos:

<país>
     <ciudad>
        <barrio> 
        </barrio> 
        <barrio> 
        </barrio> 
     </ciudad> 
     <ciudad> 
        <barrio> 
        </barrio> 
     </ciudad> 
</país>

En este ejemplo, tenemos un país con dos ciudades en él. La primera ciudad tiene dos barrios, al igual que la segunda. El país es padre de las ciudades, y éstas son hermanas.

Pero esta información, hasta ahora, no es muy útil; todavía no especificamos de qué países y ciudades estamos hablando. Podemos hacer eso mediante atributos que van dentro de las etiquetas:

<nombre de país="Estados Unidos" población="311591917">
     <nombre de ciudad="New York" población="8336697">
        <nombre de barrio="East Villedad">
        </barrio>
        <nombre de barrio="Harlem">
        </barrio>
     </ciudad>
     <nombre de ciudad="Los Angeles" población="3819702">
        <nombre de barrio="Hollywood">
        </barrio>
     </ciudad>
</país>

Ahora cada elemento tiene atributos. Ya sabemos qué población tienen el país y las ciudades, así como los nombres de todo. Podemos añadir todos los atributos que queramos. El nombre dentro de la etiqueta nos dice qué tipo de cosa es la del elemento, y los atributos nos dan detalles sobre esa cosa.

Cuando tienes una lista de cosas similares en XML, puedes ver una lista de ciudades gemelas:

<país>
     <ciudad></ciudad>
     <ciudad></ciudad>
     <ciudad></ciudad>
     <ciudad></ciudad>
     <ciudad></ciudad>
     </país>

Algunas veces obtendremos una lista que encierra ciertos elementos como estos:

<país>
     <ciudades>
        <ciudad></ciudad>
        <ciudad></ciudad>
        <ciudad></ciudad>
        <ciudad></ciudad>
        <ciudad></ciudad>
     </ciudades>
</país>

Pero no es un requisito. Cuando tienes pedazos de datos individuales sobre un elemento (texto, números, una fecha, ese tipo de cosas), puedes ponerlos como atributos, pero también como contenidos de una etiqueta. Éstos podrían ser equivalentes:

<ciudad nombre="Los Angeles"></ciudad>
<ciudad>
<nombre>Los Angeles</nombre>
</ciudad>

Las razones por las que alguien querría emplear el primer o el segundo formato en XML son muy diferentes. Si usas un atributo, no debes tener otro atributo con el mismo nombre. Asimismo, un atributo es texto y números, por lo que no puedes “anidar” información en él. Aunque los dos ejemplos sirven para decir que hay una ciudad que se llama “Los Angeles”, uno de ellos (el que lo hace mediante atributos) no podría expresar que hay una ciudad dentro de un país, o una ciudad que tiene varios nombres.

Esto funciona:

<país>
     <nombre de ciudad="Los Angeles"></ciudad>
</país>

Esto NO funciona:

<país ciudad="<nombre de ciudad="Los Angeles"></ciudad>">
</país>

Esto funciona:

<ciudad>
     <nombre>Los Angeles</nombre>
     <nombre>LA</nombre>
</ciudad>

Esto NO funciona:

<nombre ciudad="Los Angeles" nombre="LA">
</nombre>

Nota: Algunas veces también verás etiquetas de apertura que no van acompañadas por etiquetas de cierre completas, como ésta:

<nombre ciudad="Los Angeles" />

Se trata de una manera de declarar un elemento vacío. Estas formulaciones son equivalentes:

<nombre de ciudad="Los Angeles"></ciudad>
<nombre de ciudad="Los Angeles" />

Para finalizar, cuando veas un documento XML, debes de entender:

• Un documento XML es una jerarquía de elementos.

• Los elementos se encuentran formados por etiquetas de apertura y cierre y lo que se encuentra entre ellas (que puede ser texto o números, o ambos, o nada).

• La etiqueta de apertura también puede tener atributos en el formato: nombre=»valor».Cada valor debe de contener texto y números y no otros elementos.

Nota: Al utilizar XML o JSON, siempre existe la misma duda: ¿Cómo guardamos datos especiales como fechas y tiempo? Es fácil: guárdalo como texto o números como lo harías de forma habitual. Sólo te recomendamos que siempre utilices el mismo formato (“10/18/2012″ u “Octubre 8, 2012″).

Lo básico sobre JSON

JSON es un poco más complejo que XML, a menos que tengas experiencia con JavaScript. JSON es un formato que consiste básicamente en arreglos y objetos. Cuando algo está delimitado por  [] corchetes es un arreglo, y cuando esté rodeada por {} llaves, es un objeto.

Arreglos

Los arreglos son listas de cosas en orden separadas por comas. Por ejemplo:

["New York","Los Angeles","Chicago","Miami"]

Nueva York es primero; Miami, el último. No tiene que importarte el orden; sólo recuerda que sí existe. Los elementos de un arreglo pueden ser datos (como texto o un número), pero también pueden ser objetos u otros arreglos.

[["New York","Los Angeles","Chicago"],["Florencia","Venecia","Roma"]]

Esta lista tiene dos elementos: el primero es una lista de 3 ciudades de Estados Unidos, y el segundo es una lista de 3 ciudades italianas.

[{"nombre":"New York"},{"nombre":"Los Angeles"},{"nombre":"Chicago"}]

No te preocupes por los detalles de la lista; sólo recuerda que es una lista de tres elementos, y cada uno es un objeto.

Un arreglo es una lista, pero puede tener un solo elemento. Estos arreglos son perfectamente válidos:

[]
["Sólo un elemento"]

Objetos

Los objetos también se ven como listas de cosas, pero no debes verlas como listas. Cada elemento se llama “propiedad” y tiene un nombre y un valor. El nombre siempre está entre comillas, y debe aparecer sólo una vez en un objeto. Son muy similares a los atributos que aparecen en el formato XML, como éste:

{
"nombre": "Los Angeles",
"población": 3819702
}

Este ejemplo NO es correcto

{
"nombre": "Los Angeles",
"nombre": "LA",
"población": 3819702
}

Como un arreglo, los valores pueden ser textos o números, pero también pueden ser arreglos de otras cosas. Para ejemplificar el caso anterior, podemos ver lo siguiente:

{
"nombres": ["Los Angeles","LA"],
"población": 3819702
}

Otros dos ejemplos:

{
"nombre": "United States",
"ciudades": ["New York","Los Angeles","Chicago"]
}
{
"nombre": "United States",
"líderes": {
"presidente": "Barack Obama",
"vicepresidente": "Joe Biden"
}
}

Nota: Puedes usar espacios en los nombres (como “vice presidente”), pero debes de evitarlo. Es mejor usar “vicepresidente” o “vice_presidente”, pues los espacios pueden ser problemáticos si son incorporados a código más tarde.

Un arreglo se utiliza para expresar una lista plana de cosas (como elementos hermanos en XML), y un objeto se utiliza para expresar los detalles específicos sobre una cosa (como los atributos de elemento en XML).

Podríamos, por ejemplo, utilizar un objeto para enumerar las ciudades, pero como cada propiedad requiere un nombre único, tendría que especificar un nombre para cada entrada:

{
"ciudad1": "Los Angeles",
"ciudad2": "New York",
"ciudad3": "Chicago"
}

Es mejor usar un arreglo para que tus datos sean más flexibles. Así puedes añadir y quitar elementos de manera más fácil. También así será más fácil después utilizar código para determinar cuántas ciudades están en la lista, por ejemplo.

{
"ciudades": ["New York","Los Angeles","Chicago"]
}

Lo opuesto también es correcto. Podrías usar un arreglo para una lista de propiedades.

["Los Angeles","California",3819702]

Puedes usar eso mientras recuerdes que el primer elemento de la lista es el nombre de la ciudad, el segundo elemento es el estado en el que se encuentra, y el tercer elemento es la población de la ciudad. Pero… ¿Para qué molestarse? El uso de un objeto es mejor cuando se trata de propiedades únicas sobre la ciudad. Un objeto es más descriptivo. Si tienes que agregar o quitar propiedades, es mucho más fácil.

Ejemplo:

{
"nombre": "Los Angeles",
"estado": "California",
"población": 3819702
}

Una vez que comprendas esos conceptos gemelos, JSON cobrará sentido para ti.

• Los arreglos son listas planas. Tienen un tamaño y una secuencia. Si tienes más de una instancia de una cosa, el arreglo es la herramienta adecuada.

• Los objetos son para cosas que tienen una sola descripción. Las propiedades se escriben como una lista (pero no pienses en ellos como una lista). Piensa como un objeto como un perfil.

En conclusión: JSON se compone de dos tipos de “nidos”: objetos y arreglos. Cada objeto puede tener otro objeto o un arreglo como valor. Cada arreglo puede tener otros arreglos u objetos como elementos de la lista.

[
{
"nombre": "Estados Unidos",
"población": 311591917,
"ciudades": [
{
"nombre": "New York",
"población": 8336697
},
{
"nombre": "Los Angeles",
"población": 3819702
}
]
},
{
"nombre": "Italia",
"población": 60626442,
"ciudades": [
{
"nombre": "Roma",
"población": 2777979
},
{
"nombre": "Florencia",
"población": 357318
}
]
},
]

Éste es un arreglo que tiene dos objetos dentro de él; cada uno representa un país. Tiene propiedades para el nombre del país y de la población. También tienen una tercera propiedad: «ciudades», cuyo valor es un arreglo. Este arreglo contiene otros dos objetos; cada uno representa a una ciudad con el nombre y la población. Parece confuso, pero es una manera muy flexible y lógica para almacenar esta información una vez que entiendes como funciona.

En resumen, para usar JSON, es necesario comprender:

• Un arreglo es una lista fija de valores. Estos valores pueden ser datos sencillos, o pueden ser arreglos u objetos.

• Un objeto es un conjunto de propiedades con nombre que describen algo. Cada uno tiene un valor, y ese valor puede ser de datos simples o puede ser un arreglo o un objeto en sí mismo.

Para reflexionar

Si tienes que elegir entre XML o JSON, usa el que te parezca más familiar, a menos de que estos datos vayan a tener conexión alguna con una aplicación web. Si alguien va a usar JavaScript con los datos, entonces usa JSON, que es totalmente compatible con JavaScript.

También ten en mente que existen múltiples maneras razonables para estructurar los mismos datos. Quien haya estructurado los datos a que tienes acceso puede haber tenido mil razones para estructurarlos como lo hizo. Simplemente concéntrate en comprender la estructura que tienen antes de empezar a modificar.

Ejemplo: La pelea en Manila

Los encuentros de boxeo generalmente tienen algo que se conoce como el pesaje, en el que se compara las características físicas de cada boxeador. Aquí te damos un ejemplo de un pesaje hecho para la pelea entre Muhammad Ali y Joe Frazier:

Así lo podrías expresar en formato XML:

<nombre luchador="Joe Frazier">
     <edad>31</edad>
     <peso>210</peso>
     <estatura>71.5</estatura>
     <alcance>73.5</alcance>
     <biceps>15.5</biceps>
     <pecho>
        <normal>43</normal>
        <expandido>45</expandido>
     </pecho>
     <cintura>34.5</cintura>
     <muslo>26.5</muslo>
     <cuello>18</cuello>
     <pantorrilla>15</pantorrilla>
</luchador>

Puedes especificar las unidades para que sea más útil:

<nombre luchador="Joe Frazier">
     <edad>31</edad>
     <peso unit="pounds">210</peso>
     <medidas unit="inches">
        <estatura>71.5</estatura>
        <alcance>73.5</alcance>
        <biceps>15.5</biceps>
        <pecho>
            <normal>43</normal>
            <expandido>45</expandido>
        </pecho>
        <cintura>34.5</cintura>
        <thigh>26.5</thigh>
        <cuello>18</cuello>
        <pantorrilla>15</pantorrilla>
     </medidas>
</fighter>

O también puedes poner todos los datos en la etiqueta de <luchador> siempre y cuando fusiones las dos medidas del pecho.

<luchador nombre="Joe Frazier" edad="31" peso="210" estatura="71.5" alcance="73.5" biceps="15.5" pecho-normal="43" pecho-expandido="45" cintura="34.5" muslo="26.5" cuello="18" pantorrilla="15"/>

Así se vería en JSON:

{
  "nombre": "Joe Frazier",
  "edad": 31,
  "medidas": {
     "peso": 210,
     "estatura": 71.5,
     "alcance": 73.5,
     "biceps": 15.5,
     "pecho": {
        "normal": 43,
        "expandido": 45
     },
     "cintura": 34.5,
     "muslo": 26.5,
     "cuello": 18,
     "pantorrilla": 15
  }
}

Ahora imaginemos que quieres mostrar ambos peleadores, junto con información acerca de la pelea:

<ubicación pelea="Manila, Filipinas" fecha="Septiembre 30, 1975">
     <luchador nombre="Joe Frazier">
        <edad>31</edad>
        <peso unidad="libras">210</peso>
        <medidas unidad="pulgadas">
            <estatura>71.5</estatura>
            <alcance>73.5</alcance>
            <biceps>15.5</biceps>
            <pecho>
                <normal>43</normal>
                <expandido>45</expandido>
            </pecho>
            <cintura>34.5</cintura>
            <muslo>26.5</muslo>
            <cuello>18</cuello>
            <pantorrilla>15</pantorrilla>
      </medidas>
 </luchador>

 <nombre luchador="Muhammad Ali">
        <edad>33</edad>
        <peso unidad="libras">220</peso>
        <medidas unidad="pulgadas">
            <estatura>75</estatura>
            <alcance>80</alcance>
            <biceps>15</biceps>
            <pecho>
               <normal>44</normal>
               <expandido>46</expandido>
            </pecho>
            <cintura>34</cintura>
            <muslo>26</muslo>
            <cuello>17.5</cuello>
            <pantorrilla>17</pantorrilla>
        </medidas>
     </luchador>
</pelea>

En JSON la información se ve así:

{
  "ubicación": "Manila, Filipinas",
  "fecha": "September 30, 1975",
  "luchadores": [
    {
      "nombre": "Joe Frazier",
      "sobrenombres": [
      "Smokin' Joe"
      ],
     "ciudad natal": "Philadelphia, PA",
     "edad": 31,
     "peso": 210,
     "medidas": {
       "estatura": 71.5,
       "alcance": 73.5,
       "biceps": 15.5,
       "pecho": {
         "normal": 43,
         "expandido": 45
         },
       "cintura": 34.5,
       "muslo": 26.5,
       "cuello": 18,
       "pantorrilla": 15
     }
  },
  {
      "nombre": "Muhammad Ali",
      "sobrenombres": [
        "The Louisville Lip",
        "The Greatest"
        ],
      "ciudad natal": "Louisville, KY",
      "edad": 33,
      "peso": 220,
      "medidas": {
        "estatura": 75,
        "alcance": 80,
        "biceps": 15,
        "pecho": {
           "normal": 44,
           "expandido": 46
           },
        "cintura": 34,
        "muslo": 26,
        "cuello": 17.5,
        "pantorrilla": 17
       }
   }
 ]
}

Observa que la pelea tiene tres propiedades: la ubicación, la fecha, y los boxeadores. El valor de «boxeadores» es un arreglo con dos elementos. Cada uno de esos elementos es un objeto que describe las características del luchador. La mayor parte de esos datos es sólo un número, pero, por ejemplo, «apodos» es un arreglo porque un boxeador puede tener cualquier número de apodos. Si supieras que el boxeador tiene un solo apodo, no necesitarías agregar esa matriz.

Creando con XML y JSON

Este manual está principalmente diseñado para que entiendas vagamente la estructura de XML y JSON. Ser capaz de crear XML o JSON requiere una comprensión más detallada y quisquillosa de la sintaxis. Mientras tanto, si tienes datos en una tabla (por ejemplo, un archivo de Excel), y quieres convertirlo en XML o JSON, o lo que deseas es ver cómo se ve como XML / JSON con fines de aprendizaje, te recomendamos utilizar este recurso.