JSON Zelfstudie
Aan de slag met JSON

Opmerkingen

versies

JSON syntaxisregels

JSON (JavaScript Object Notation) syntaxis is gebaseerd op een subset van JavaScript (zie ook json.org ).

Een geldige JSON-expressie kan een van de volgende gegevenstypen zijn

• eenvoudige gegevenstypen: String, Number, Boolean, Null
• samengestelde gegevenstypen: waarde, object, array

Eenvoudige gegevenstypen

Een JSON-string moet tussen dubbele aanhalingstekens worden geplaatst en mag nul of meer Unicode-tekens bevatten; backslash-ontsnappingen zijn toegestaan. Geaccepteerde JSON-nummers staan in E-notatie . Boolean is er een van true , false . Null is het gereserveerde trefwoord null .

Samengestelde gegevenstypen

Een JSON-waarde kan een van de volgende zijn: String, Number, Boolean, Null, Object, Array.

Een JSON-object is een door komma's gescheiden ongeordende verzameling naam: waardeparen ingesloten tussen accolades, waarbij naam een String is en waarde een JSON-waarde.

Een JSON-array is een geordende verzameling JSON-waarden.

Voorbeeld van een JSON-array:

["home", "wooden"]

Voorbeelden van JSON-objecten:

{
    "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"]
  }
]

Online tools voor het valideren en opmaken van JSON-gegevens:

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

JSON Object

Een JSON-object is omgeven door accolades en bevat sleutel / waarde-paren.

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

Sleutels moeten geldige tekenreeksen zijn, dus omgeven door dubbele aanhalingstekens. Waarden kunnen JSON-objecten, getallen, tekenreeksen, arrays of een van de volgende 'letterlijke namen' zijn: false , null of true . In een sleutel / waarde-paar wordt de sleutel van de waarde gescheiden door een dubbele punt. Meerdere sleutel / waarde-paren worden gescheiden door komma's.

Orde in objecten is niet belangrijk. Het volgende JSON-object is dus equivalent aan het bovenstaande:

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

Kortom, dit is een voorbeeld van een geldig JSON-object:

{
  "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]
  }
}

Algemene voorbeelden van JSON-objecten, met gerelateerde (Java) objecttegenhangers

In dit voorbeeld wordt aangenomen dat het 'root'-object dat wordt geserialiseerd naar JSON een instantie is van de volgende klasse:

public class MyJson {
}

Voorbeeld 1: een voorbeeld van een exemplaar van MyJson , zoals:

{}

dat wil zeggen omdat de klasse geen velden heeft, worden alleen accolades geserialiseerd. Krullende haakjes zijn de algemene scheidingstekens die een object vertegenwoordigen . Merk ook op hoe het root-object niet is geserialiseerd als een sleutel / waarde-paar. Dit geldt ook voor eenvoudige typen (tekenreeks, getallen, arrays) wanneer het geen velden van een (buitenste) object zijn.

Voorbeeld 2: Laten we enkele velden toevoegen aan MyJson en deze initialiseren met enkele waarden:

// 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();    
}

Dit is de gerelateerde JSON-weergave:

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

Merk op dat alle velden in een seriewaardenstructuur zijn geserialiseerd, waarbij de sleutel de naam is van het veld dat de waarde bevat. De gemeenschappelijke scheidingstekens voor arrays zijn vierkante haken. Merk ook op dat elk sleutel / waarde-paar wordt gevolgd door een komma, behalve het laatste paar.

JSON Array

Een JSON-array is een geordende verzameling waarden. Het wordt omgeven door vierkante accolades, dwz [] , en waarden worden door komma's gescheiden:

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

JSON-arrays kunnen ook elk geldig JSON-element bevatten, inclusief objecten, zoals in dit voorbeeld van een array met 2 objecten (overgenomen uit het RFC-document):

[
  {
     "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"
  }
]

Ze kunnen ook elementen met gemengde types bevatten, bijvoorbeeld:

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

Een veelgemaakte fout bij het schrijven van JSON-arrays (en objecten) is om een volgkomma achter te laten na het laatste element. Dit is een gebruikelijk patroon in vele talen, maar is helaas niet geldig in JSON. De volgende array is bijvoorbeeld ongeldig:

[
    1,
    2,
]

Om dit geldig te maken, zou je de komma na het laatste element moeten verwijderen en het veranderen in:

[
    1,
    2
]

JSON handmatig bewerken

JSON is een zeer strikt formaat (zie http://json.org) . Dat maakt het gemakkelijk om te parseren en te schrijven voor machines, maar verrast mensen wanneer een onopvallende fouten het document breken.

Veel voorkomende problemen

Volgkomma

In tegenstelling tot de meeste programmeertalen is het niet toegestaan om een volgkomma toe te voegen:

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

Het toevoegen van een komma na 3 levert een synaxfout op.

Hetzelfde probleem bestaat voor arrays:

[ 
  1,
  2
]

U moet extra voorzichtig zijn als u de artikelen opnieuw wilt bestellen.

Comma ontbreekt

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

Omdat volgkomma's niet zijn toegestaan, is het gemakkelijk om te vergeten een toe te voegen voordat u een nieuwe waarde toevoegt (in dit geval na 3 ).

Comments

JSON staat geen opmerkingen toe omdat het een gegevensuitwisselingsformaat is. Dit is nog steeds een hot topic, maar er zijn geen duidelijke antwoorden anders dan om ze niet te gebruiken.

Er zijn verschillende oplossingen:

• Gebruik opmerkingen in C-stijl en verwijder ze vervolgens voordat je het aan de parser doorgeeft
• Sluit opmerkingen in de gegevens in

{
  "//": "comment",
  "data": 1
}

• Sluit opmerkingen in en overschrijf ze met gegevens

{
  "data": "comment",
  "data": 1
}

De tweede data overschrijft de opmerking in de meeste parsers .

Oplossingen

Om het schrijven van JSON te vergemakkelijken, gebruikt u een IDE die op syntaxisfouten controleert en syntaxiskleuring biedt. Plug-ins zijn beschikbaar voor de meeste editors.

Wanneer u applicaties en hulpmiddelen ontwikkelt, gebruikt u JSON intern en als protocol, maar probeer het niet bloot te leggen op plaatsen waar een mens het waarschijnlijk met de hand zou moeten bewerken (behalve voor foutopsporing).

Evalueer andere formaten die beter geschikt zijn voor dit gebruik, zoals:

• Hjson , kan naadloos worden omgezet van en naar JSON
• TOML , vergelijkbaar met INI-bestanden
• YAML , meer functies maar ten koste van extra complexiteit

Rationale voor Array vs Object (dat wil zeggen wanneer wat te gebruiken)

JSON-arrays vertegenwoordigen een verzameling objecten. In JS is er een verzameling verzamelfuncties, zoals slice , pop , push . Objecten hebben gewoon meer onbewerkte gegevens.

Een JSONArray is een geordende reeks waarden . De externe tekstvorm is een tekenreeks tussen vierkante haken met komma's die de waarden scheiden.

Een JSONObject is een ongeordende verzameling naam / waarde- paren. De externe vorm is een string gewikkeld in accolades met dubbele punten tussen de namen en waarden en komma's tussen de waarden en namen.

Object - sleutel en waarde, matrix - cijfers, tekenreeksen, booleans. Wanneer gebruik je dit of dat?

Je kunt Arrays beschouwen als "is een / een" en objecten als "heeft een". Laten we "Fruit" als voorbeeld gebruiken. Elk item in fruitarray is een soort fruit.

array fruit : [orange, mango, banana]

Arrays kunnen objecten, tekenreeksen, getallen, arrays bevatten, maar laten alleen objecten en arrays behandelen.

array fruit : [orange:[], mango:{}, banana:{}]

. Je kunt zien dat oranje ook een array is. Het betekent dat elk item dat oranje wordt, een soort sinaasappel is, bijvoorbeeld: bittere sinaasappel, mandarijn, zoete sinaasappel.

voor fruitobjecten is elk item erin een eigenschap van fruit. dus de vrucht heeft een

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

Dit houdt ook in dat alles in het seed-object eigendom van seed moet zijn, bijvoorbeeld: kleur, ..

JSON is voornamelijk een taal waarmee JavaScript-objecten in tekenreeksen kunnen worden geserialiseerd. Dus bij het deserialiseren van een JSON-string moet u een javascript-objectstructuur krijgen. Als uw json deserialiseert in een object dat 100 objecten met de naam object1 tot object100 opslaat, is dat erg onhandig. De meeste deserializers verwachten dat je bekende objecten en arrays van bekende objecten hebt, zodat ze de tekenreeksen kunnen converteren naar de werkelijke objectstructuur in de taal die je gebruikt. Dit is ook een vraag die de filosofie van objectgeoriënteerd ontwerp zou beantwoorden.

credits to all particiapnts Wat zijn de verschillen tussen het gebruik van JSON-arrays versus JSON-objecten?