JSON Handledning
Komma igång med JSON

Anmärkningar

versioner

JSON Syntax-regler

JSON (JavaScript Object Notation) -syntax är baserad på en delmängd av JavaScript (se även json.org ).

Ett giltigt JSON-uttryck kan vara en av följande datatyper

• enkla datatyper: String, Number, Boolean, Null
• sammansatta datatyper: Värde, Objekt, Array

Enkla datatyper

En JSON-sträng måste bifogas i dubbla citat och kan innehålla noll eller fler Unicode-tecken; backslash-flykt är tillåtna. Godkända JSON-nummer finns i E-notation . Boolean är en av true , false . Null är det reserverade nyckelordet null .

Sammansatta datatyper

Ett JSON-värde kan vara ett av: String, Number, Boolean, Null, Object, Array.

Ett JSON-objekt är en kommaseparerad oordnad samling av namn: värdepar som är inneslutna i lockiga parenteser där namnet är ett sträng och värdet ett JSON-värde.

En JSON Array är en ordnad samling av JSON-värden.

Exempel på en JSON-grupp:

["home", "wooden"]

Exempel på JSON-objekt:

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

Onlineverktyg för validering och formatering av JSON-data:

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

JSON-objekt

Ett JSON-objekt är omgivet av lockiga hängslen och innehåller par med nyckelvärden.

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

Nycklar måste vara giltiga strängar, därmed omgiven av dubbla citattecken. Värden kan vara JSON-objekt, nummer, strängar, matriser eller ett av följande 'bokstavliga namn': false , null eller true . I ett nyckelvärdespar separeras nyckeln från värdet av en kolon. Flera nyckelvärden-par separeras med komma-tecken.

Ordning i objekt är inte viktig. Följande JSON-objekt motsvarar således ovan:

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

För att sammanfatta allt är detta ett exempel på ett giltigt JSON-objekt:

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

Vanliga exempel på JSON-objekt, med relaterade (Java) -objekt motsvarigheter

Genom hela detta exempel antas att "root" -objektet som serielliseras till JSON är ett exempel på följande klass:

public class MyJson {
}

Exempel 1: Ett exempel på ett exempel på MyJson , som är:

{}

dvs eftersom klassen inte har några fält, är endast lockiga parenteser serialiserade. Lockiga parenteser är de vanliga avgränsarna för att representera ett objekt . Lägg också märke till hur rotobjektet inte är serialiserat som ett nyckelvärdespar. Detta gäller också för enkla typer (sträng, nummer, matriser) när de inte är fält i ett (yttre) objekt.

Exempel 2: Låt oss lägga till några fält till MyJson och initiera dem med några värden:

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

Detta är den relaterade JSON-representationen:

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

Lägg märke till hur alla fält är serialiserade i en nyckelvärdesstruktur, där nyckeln är namnet på det fält som innehar värdet. De vanliga avgränsarna för matriser är fyrkantiga parenteser. Lägg märke till att varje nyckelvärdespar följs av komma, med undantag för det sista paret.

JSON Array

En JSON Array är en ordnad samling av värden. Det är omgivet av fyrkantiga hängslen, dvs [] , och värdena är kommaavgränsade:

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

JSON Arrays kan också innehålla alla giltiga JSON-element, inklusive objekt, som i detta exempel på en matris med två objekt (hämtade från RFC-dokumentet):

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

De kan också innehålla element med blandade typer, till exempel:

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

Ett vanligt misstag när du skriver JSON-matriser (och objekt) är att lämna en efterföljande komma efter det sista elementet. Detta är vanligt mönster på många språk, men är tyvärr inte giltigt i JSON. Till exempel är följande array ogiltig:

[
    1,
    2,
]

För att göra detta giltigt måste du ta bort komma efter det sista elementet och göra det till:

[
    1,
    2
]

Redigering av JSON för hand

JSON är ett mycket strikt format (se http://json.org) . Det gör det enkelt att analysera och skriva för maskiner men överraskar människor när osynliga misstag bryter dokumentet.

Vanliga problem

Släp Komma

Till skillnad från de flesta programmeringsspråk får du inte lägga till en efterföljande komma:

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

Att lägga till ett komma efter 3 kommer att skapa ett synaxfel.

Samma problem finns för matriser:

[ 
  1,
  2
]

Du måste vara extra försiktig om du behöver ordna om föremålen.

Komma saknas

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

Eftersom efterföljande komma inte är tillåtna är det lätt att glömma att lägga till ett innan du lägger till ett nytt värde (i detta fall efter 3 ).

kommentarer

JSON tillåter inte kommentarer eftersom det är ett datautbytesformat. Detta är fortfarande ett hett ämne men utan tydliga svar än att inte använda dem.

Det finns flera lösningar:

• Använd kommentarer i C-stil och ta bort dem innan du överför dem till tolkaren
• Bädda in kommentarer i data

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

• Bädda in kommentarer och skriva över dem med data

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

Den andra data posten skrivs kommentaren i de flesta tolkar.

lösningar

För att göra det lättare att skriva JSON använder du en IDE som kontrollerar syntaxfel och ger syntaxfärgning. Plugins är tillgängliga för de flesta redaktörer.

När du utvecklar applikationer och verktyg använder du JSON internt och som ett protokoll men försök att inte exponera det på platser där en människa troligtvis skulle behöva redigera den för hand (utom för felsökning).

Utvärdera andra format som är bättre lämpade för detta bruk, som:

• Hjson , kan konverteras sömlöst till och från JSON
• TOML , liknande INI-filer
• YAML , fler funktioner men till en kostnad av extra komplexitet

Rationale för Array vs Object (dvs. när man ska använda vad)

JSON-matriser representerar en samling objekt. I JS finns det ett gäng samlingsfunktioner av dem som slice , pop , push . Objekt har bara mer rå data.

En JSONArray är en ordnad sekvens av värden . Dess externa textform är en sträng som är lindad i fyrkantiga parenteser med komma som skiljer värdena.

En JSONObject är en oordnad samling av namn- / värdepar . Dess yttre form är en sträng som är lindad i lockiga hängslen med kolon mellan namn och värden och komma mellan värden och namn.

Objekt - nyckel och värde, Array - siffror, strängar, booléer. När använder du det här eller det?

Du kan tänka på Arrays som "är ett / ett" och objekt som "har ett". Låt oss använda "Fruit" som exempel. Varje artikel i fruktmatrisen är en typ av frukt.

array fruit : [orange, mango, banana]

Matriser kan innehålla föremål, strängar, siffror, matriser, men låter bara hantera objekt och matriser.

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

. Du kan se att orange är en matris också. Det innebär att alla objekt som går int orange är en typ av apelsin, säg: bitter_orange, mandarin, sweet_orange.

för fruktobjekt är alla objekt i det ett attribut till frukt. således har frukten en

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

Detta innebär också att allt inom fröobjektet bör vara egendom för frö, säga: färg, ..

JSON är främst ett språk som gör det möjligt att serialisera javascriptobjekt i strängar. Så vid deserialisering av en JSON-sträng bör du få en javascript-objektstruktur. Om din json deserialiserar till ett objekt som lagrar 100 objekt som kallas objekt1 till objekt100, kommer det att bli väldigt obekvämt. De flesta deserializers förväntar dig att du har kända objekt och matriser av kända objekt så att de kan konvertera strängarna till den faktiska objektstrukturen på det språk du använder. Detta är också en fråga som filosofin om objektorienterad design skulle svara dig.

poäng till alla deltagare Vilka är skillnaderna mellan att använda JSON-matriser kontra JSON-objekt?