Primeros pasos con JSON

Matriz JSON

Una matriz JSON es una colección ordenada de valores. Está rodeado por llaves cuadradas, es decir, [], y los valores están delimitados por comas:

{ "colors" : [ "red", "green", "blue" ] }

Los arreglos JSON también pueden contener cualquier elemento JSON válido, incluidos los objetos, como en este ejemplo de un arreglo con 2 objetos (tomado del documento RFC):

[
  {
     "precision": "zip",
     "Latitude":  37.7668,
     "Longitude": -122.3959,
     "Address":   "",
     "City":      "SAN FRANCISCO",
     "State":     "CA",
     "Zip":       "94107",
     "Country":   "US"
  },
  {
     "precision": "zip",
     "Latitude":  37.371991,
     "Longitude": -122.026020,
     "Address":   "",
     "City":      "SUNNYVALE",
     "State":     "CA",
     "Zip":       "94085",
     "Country":   "US"
  }
]

También pueden contener elementos con tipos mixtos, por ejemplo:

[
    "red",
    51,
    true,
    null,
    {
        "state": "complete"
    }
]

Un error común al escribir matrices JSON (y objetos) es dejar una coma final después del último elemento. Este es un patrón común en muchos idiomas, pero desafortunadamente no es válido en JSON. Por ejemplo, la siguiente matriz no es válida:

[
    1,
    2,
]

Para que esto sea válido, deberá eliminar la coma después del último elemento, convirtiéndolo en:

[
    1,
    2
]

Objeto JSON

Un objeto JSON está rodeado de llaves y contiene pares clave-valor.

{ "key1": "value1", "key2": "value2", ... }

Las claves deben ser cadenas válidas, por lo tanto entre comillas dobles. Los valores pueden ser objetos JSON, números, cadenas, matrices o uno de los siguientes “nombres literales”: “falso”, “nulo” o “verdadero”. En un par clave-valor, la clave está separada del valor por dos puntos. Varios pares clave-valor están separados por comas.

El orden en los objetos no es importante. El siguiente objeto JSON es equivalente al anterior:

{ "key2": "value2", "key1": "value1", ... }

Para resumir todo, este es un ejemplo de un objeto JSON válido:

{
  "image": {
    "width":  800,
    "height": 600,
    "title":  "View from 15th Floor",
    "thumbnail": {
      "url": "http://www.example.com/image/481989943",
      "height": 125,
      "width":  100
    },
    "visible": true,
    "ids": [116, 943, 234, 38793]
  }
}

Ejemplos comunes de objetos JSON, con contrapartes de objetos relacionados (Java)

A lo largo de este ejemplo, se supone que el objeto ‘raíz’ que se serializa en JSON es una instancia de la siguiente clase:

public class MyJson {
}

 

Ejemplo 1 : Un ejemplo de una instancia de MyJson, como es:

{}

es decir, dado que la clase no tiene campos, solo se serializan corchetes. Los corchetes son los delimitadores comunes para representar un objeto. Observe también cómo el objeto raíz no es serializado como un par clave-valor. Esto también es cierto para tipos simples (Cadena, números, arreglos) cuando no son campos de un objeto (externo).

 

Ejemplo 2: Agreguemos algunos campos a MyJson e inicialicemos con algunos valores:

// another class, useful to show how objects are serialized when inside other objects
public class MyOtherJson {} 

// an enriched version of our test class
public class MyJson {
  String myString = "my string";
  int myInt = 5;
  double[] myArrayOfDoubles = new double[] { 3.14, 2.72 };
  MyOtherJson objectInObject = new MyOtherJson();    
}

Esta es la representación JSON relacionada:

{
  "myString" : "my string",
  "myInt" : 5,
  "myArrayOfDoubles" : [ 3.14, 2.72 ],
  "objectInObject" : {}
}

Observe cómo todos los campos se serializan en una estructura clave-valor, donde la clave es el nombre del campo que contiene el valor. Los delimitadores comunes para matrices son corchetes. Observe también que cada par clave-valor va seguido de una coma, excepto el último par.

Edición de JSON a mano

JSON es un formato muy estricto (ver http://json.org). Eso hace que sea fácil de analizar y escribir para las máquinas, pero sorprende a los humanos cuando un error discreto rompe el documento.

Problemas comunes

Coma final

A diferencia de la mayoría de los lenguajes de programación, no se le permite agregar una coma final:

{
  a: 1,
  b: 2,
  c: 3
}

Agregar una coma después de 3 producirá un error de sinax.

El mismo problema existe para las matrices:

[ 
  1,
  2
]

Debe tener especial cuidado si necesita reordenar los artículos.

Coma faltante

{
  a: 1,
  b: 2,
  c: 3
  d: 4
}

Dado que no se permiten las comas finales, es fácil olvidar agregar una antes de agregar un nuevo valor (en este caso, después de 3).

Comentarios

JSON no permite comentarios ya que es un formato de intercambio de datos. Este sigue siendo un tema candente, aunque sin respuestas claras aparte de no usarlos.

Hay varias soluciones:

  • Use comentarios de estilo C, luego elimínelos antes de pasarlo al analizador
  • Incrustar comentarios en los datos
{
  "//": "comment",
  "data": 1
}
  • Incrustar comentarios y sobrescribirlos con datos
{
  "data": "comment",
  "data": 1
}

La segunda entrada de datos sobrescribirá el comentario en la mayoría de los analizadores.

Soluciones

Para que sea más fácil escribir JSON, use un IDE que verifique los errores de sintaxis y proporcione colores de sintaxis. Los complementos están disponibles para la mayoría de los editores.

Cuando desarrolle aplicaciones y herramientas, use JSON internamente y como protocolo, pero trate de no exponerlo en lugares donde probablemente se requiera que un ser humano lo edite a mano (excepto para la depuración).

Evalúe otros formatos que se adapten mejor a este uso, como:

  • [Hjson] (http://hjson.org), se puede convertir sin problemas a y desde JSON
  • TOML, similar a los archivos INI
  • YAML, más características pero a costa de mayor complejidad

Reglas de sintaxis JSON

La sintaxis de JSON (Notación de objetos JavaScript) se basa en un subconjunto de JavaScript (ver también json.org).

Una expresión JSON válida puede ser uno de los siguientes tipos de datos

  • tipos de datos simples: cadena, número, booleano, nulo
  • tipos de datos compuestos: valor, objeto, matriz

Tipos de datos simples

Una cadena JSON debe estar entre comillas dobles y puede contener cero o más caracteres Unicode; Se permiten escapes de barra invertida. Los números JSON aceptados están en [nota E] (https://en.wikipedia.org/wiki/Scientific_notation#E_notation). Booleano es uno de verdadero, falso. Null es la palabra clave reservada null.

Tipo de datos Ejemplos de JSON válidos
### Cadena "manzana"
"manzana"
"\u00c4pfel\n"
""
### Número 3
1.4
-1.5e3
### Booleano verdadero
falso
### Nulo nulo

Tipos de datos compuestos

Valor

Un valor JSON puede ser uno de: cadena, número, booleano, nulo, objeto, matriz.

Objeto

Un objeto JSON es una colección desordenada, separada por comas, de pares nombre:valor encerrados entre corchetes, donde el nombre es una cadena y el valor es un valor JSON.

Matriz

Una matriz JSON es una colección ordenada de valores JSON.

Ejemplo de una matriz JSON:

["home", "wooden"]

Ejemplos de objetos JSON:

{
    "id": 1,
    "name": "A wooden door",
    "price": 12.50,
    "tags": ["home", "wooden"]
}

[
  1,
  2,
  [3, 4, 5, 6],
  {
    "id": 1,
    "name": "A wooden door",
    "price": 12.50,
    "tags": ["home", "wooden"]
  }
]

Herramientas en línea para validar y formatear datos JSON:

  • http://jsonlint.com/
  • http://www.freeformatter.com/json-validator.html
  • http://jsonviewer.stack.hu/
  • http://json.parser.online.fr/

Justificación para Array vs Object (es decir, cuándo usar qué)

Las matrices JSON representan una colección de objetos. En JS, hay un montón de funciones de colección fuera de ellos, como slice, pop, push. Los objetos tienen más datos sin procesar.

Un JSONArray es una secuencia ordenada de valores. Su forma de texto externo es una cadena entre corchetes con comas que separan los valores.

Un JSONObject es una colección desordenada de pares nombre/valor. Su forma externa es una cadena entre llaves con dos puntos entre los nombres y valores, y comas entre los valores y nombres.

Objeto: clave y valor, Matriz: números, cadenas, booleanos. ¿Cuándo usas esto o aquello?

Puede pensar en matrices como “es un/un” y objetos como “tiene un”. Usemos “Fruit” como ejemplo. Cada artículo en la matriz de frutas es un tipo de fruta.

matriz de frutas: [naranja, mango, plátano]

Los arreglos pueden contener objetos, cadenas, números, arreglos, pero tratemos solo con objetos y arreglos.

matriz de frutas: [naranja:[], mango:{}, plátano:{}]

. Puedes ver que naranja también es una matriz. Implica que cualquier artículo que vaya en naranja es un tipo de naranja, digamos: naranja_amarga, mandarina, naranja_dulce.

para el objeto de fruta, cualquier artículo en él es un atributo de fruta. así la fruta tiene un

object fruit :{seed:{}, endocarp:{},flesh:{}}

Esto también implica que cualquier cosa dentro del objeto semilla debe ser propiedad de la semilla, digamos: color, ..

JSON es principalmente un lenguaje que permite serializar objetos javascript en cadenas. Entonces, al deserializar una cadena JSON, debe obtener una estructura de objeto javascript. Si su json se deserializa en un objeto que almacena 100 objetos llamados object1 a object100, eso será muy inconveniente. La mayoría de los deserializadores esperarán que tenga objetos conocidos y matrices de objetos conocidos para que puedan convertir las cadenas en la estructura del objeto real en el idioma que está utilizando. También esta es una pregunta que la filosofía del diseño orientado a objetos le respondería.

creditos a todos los participantes http://stackoverflow.com/questions/12288820/cuáles-son-las-diferencias-entre-usar-json-arrays-vs-json-objects/37646227#37646227