JSON

A Wikipédiából, a szabad enciklopédiából
JavaScript Object Notation
Fájlkiterjesztés .json
MIME-típus application/json
Kiterjesztése ennek JavaScript
Standard RFC4627
Weboldal json.org

A JSON (JavaScript Object Notation) egy kis méretű, szöveg alapú szabvány ember által olvasható adatcserére. A JavaScript szkriptnyelvből alakult ki egyszerű adatstruktúrák és asszociatív tömbök reprezentálására (a JSON-ban objektum a nevük). A JavaScripttel való kapcsolata ellenére nyelvfüggetlen, több nyelvhez is van értelmezője.

A JSON formátumot eredetileg Douglas Crockford specifikálta és az RFC4627 írja le. A JSON hivatalos mime-típusa application/json. A JSON fájlok kiterjesztése pedig .json.

A JSON-t legtöbbször egy szerver és egy kliens számítógép közti adatátvitelre használják (legtöbbször AJAX technológiával), az XML egyik alternatívájaként. Általánosságban strukturált adatok tárolására, továbbítására szolgál.

Története[szerkesztés | forrásszöveg szerkesztése]

Douglas Crockford volt az első, aki meghatározta és népszerűsítette a JSON formátumot.[1]

A JSON-t a State Software, egy többek között Crockford alapította cég használta körülbelül 2001-től. A JSON.org honlap 2002-ben indult el. 2005 decemberében a Yahoo! elkezdte némely webes szolgáltatásait JSON-ban kínálni.[2] A Google a GData webes protokolljának 2006 decemberében kezdett JSON feedeket kínálni.[3]

Habár a JSON alapja a JavaScript szkriptnyelv egy részhalmaza (konkrétan az ECMA-262 3rd Edition—December 1999 standard[4]) és gyakran használják a JavaScript programokban, a JSON programnyelvfüggetlen. JSON adatok értelmezésére és generálására igen sok programozási nyelv ad kész eszközöket. A JSON weboldalán található egy összefoglaló lista arról, hogy mely nyelvekhez vannak JSON-könyvtárak.

Adattípusok, szintaxis és példa[szerkesztés | forrásszöveg szerkesztése]

A JSON alap adattípusai:

  • Szám (double a JavaScriptben, általánosságban implementációfüggő)
  • Karakterlánc (string: idézőjelek közt, Unicode karakterekből (alapból UTF-8 kódolásban) balra dőlő törtvonallal (backslash, \) escape-elve)
  • Boolean (true (igaz) vagy false (hamis))
  • Tömb (értékek sorrendhelyes felsorolása vesszővel elválasztva, szögletes zárójelek között; az értékeknek nem kell azonos típusúnak lennie benne)
  • Objektum (kulcs:érték-párok rendezetlen gyűjteménye, amelyben ':' karakter választja el a kulcsot és az értéket, a párok egymástól vesszőkkel vannak elválasztva, a lista kapcsos zárójelek között van; a kulcsok mindig string típusúak, és különbözniük kell egymástól)
  • null (üres)

A feldolgozó által ignorált térköz hozzáadható a „strukturáló karakterek” elé vagy után (például a zárójelek „[, {, ], }”, a kettőspont „:” és a vessző „,” mellé).

A következő példa egy személyt leíró objektum JSON-os reprezentációja. Az objektum a vezetéknév és a keresztnév számára string típusú mezőket hagy, az életkornak számot, tartalmaz egy címet reprezentáló asszociatív tömböt (objektum) és egy listát (tömböt), amely a telefonszám-objektumokat tartalmazza.

{
     "vezetekNev": "Kovács",
     "keresztNev" : "János",
     "kor"      : 25,
     "cim"  :
     {
         "utcaHazszam": "2. utca 21.",
         "varos"         : "New York",
         "allam"        : "NY",
         "iranyitoSzam"   : "10021"
     },
     "telefonSzam":
     [
         {
           "tipus"  : "otthoni",
           "szam": "212 555-1234"
         },
         {
           "tipus"  : "fax",
           "szam": "646 555-4567"
         }
     ]
 }

Mivel a JSON a JavaScript részhalmaza, lehetséges (de nem ajánlott) a JSON szöveg objektumba való konvertálása a JavaScriptben található eval() függvénnyel. Például, ha a fenti JSON adat egy JavaScriptes string változóban van, melynek neve contact, p JavaScript objektumba lehet konvertálni a következőképp:

 var p = eval("(" + contact + ")");

A contact változónak azért kell zárójelek között lennie, hogy elkerülje a JavaScript szintaxisban a kétértelműségét.[5]

Mindazonáltal az ajánlott út a JSON-értelmezők használata. Ha a kliens teljes mértékben megbízik a szöveg forrásában vagy valami okból nem tökéletes szintaxisú JSON-t kell elfogadnia, csak akkor ajánlott az eval() használata. Egy jól implementált JSON-értelmező csak a hibátlan JSON-t fogadja el, és megakadályozza ezáltal a veszélyes kódok lefutását.

A modern böngészők, mint például a Firefox 4 és az Internet Explorer 8 tartalmaznak speciális lehetőségeket a JSON értelmezésére. Mivel a natív böngészős támogatás hatékonyabb és biztonságosabb, mint az eval() használata, a natív JSON-támogatás benne van a nemrégiben kiadott ECMAScript standard 5. kiadásában.[6]

Nem támogatott natív adattípusok[szerkesztés | forrásszöveg szerkesztése]

A JavaScript szintaxisa számos, JSON-ban nem megtalálható adattípust definiál:[7] dátum (Date), hiba (Error), matematikai (Math), reguláis kifejezés (Regular Expression) és függvény (Function). Ezeket a JavaScript-adattípusokat más adatformátumban kell reprezentálni, ahol a küldő és a fogadó oldal is ugyanúgy konvertálja. 2011-ben vannak de facto standardok, mint például a Date és a String közti konverzió, ám semelyiket sem ismerik el általánosan.[8][9] Más programnyelvek más, konvertálandó natív adattípusokkal rendelkezhetnek, amelyeket szerializálni kellhet az ilyen konverziók előtt.

Séma[szerkesztés | forrásszöveg szerkesztése]

Számos út van a JSON objektum struktúrájának és adattípusainak ellenőrzésére, amelyek az XML-sémára hasonlítanak, mindazonáltal az XML sémáknál a JSON-sémákat kevésbé használják széleskörűen. Ráadásul az XML-sémákkal ellentétben a JSON-sémákat kézzel kell megírni, jelenleg nincsen olyan elérhető eszköz, amely a JSON-adatokból JSON-sémát generálna.

A JSON-séma (JSON Schema)[10] egy JSON-alapú specifikáció a JSON-adatok formátumának leírására. A JSON-sémával létrehozható egy egyezmény, hogy milyen adat szükséges és mindaz milyen típusú kell, hogy legyen, nagyon hasonlóan az XML-hez való XML-sémához. A JSON Schema célja a JSON-adatok ellenőrzése, dokumentációja és interakció-szabályozás. A JSON-séma az XML Schemán, a RelaxNG-n és a Kwalify-on alapszik, de célul tűzte ki a JSON-alapúságot is, tehát a JSON-adatok validálásához használható séma formája a meglevő JSON, egyazon szerializáló eszköz használható a sémához és az adathoz, és leírhatja önmagát.

A JSON-séma egy IETF draft (vázlat) formájában íródott, amely 2011-ben lejárt.[11] Mindazonáltal számos validáló érhető el különböző programnyelvekre,[12] mindegyik különböző megfelelőségi szintekkel. Jelenleg a legteljesebb és legmegfelelőbb JSON-séma ellenőrző a JSV (JSON Schema Validator).[13]

Példa JSON-séma:

{
    "name":"Termek",
    "properties":
    {
        "id":
        {
            "type":"number",
            "description":"Termék-meghatározó",
            "required":true
        },
        "nev":
        {
            "type":"string",
            "description":"Terméknév",
            "required":true
        },
        "ar":
        {
            "type":"number",
            "minimum":0,
            "required":true
        },
        "cimkek":
        {
            "type":"array",
            "elemek":
            {
                "type":"string"
            }
        },
        "keszlet":
        {
            "type":"object",
            "properties":
            {
                "raktar":
                {
                    "type":"number"
                },
                "kereskedo":
                {
                    "type":"number"
                }
            }
        }
    }
}

A fenti JSON-séma használható például az alábbi adatok validálására:

{
    "id": 1,
    "nev": "Foo",
    "ar": 123,
    "cimkek": ["Bar","Eek"],
    "keszlet": { "raktar":300, "kereskedo":20 }
}

MIME-típus[szerkesztés | forrásszöveg szerkesztése]

A JSON-szöveg hivatalos mime-típusa application/json.[14]

Használat az Ajaxban[szerkesztés | forrásszöveg szerkesztése]

A JSON-t gyakran használják az Ajax technológiában. Az Ajax egy kifejezés arra, hogy egy weblap képes új adatokat kinyerni, még akkor is, miután a weblap betöltődött a böngészőbe, általánosságban a megjelenített weblapokon a felhasználói cselekvések hatására. Az Ajax modell részeként általában kikerül a felhasználói interfészre, dinamikusan, amint megérkezik a szerverről. Például a gyakorlatban ez lehet a következő: egy felhasználó egy szövegdobozba ír valamit egy keresőben, a kliensoldal elküldi, mit írtak be mindeddig, míg a szerver válaszol a lehetséges teljes keresőszavak listájával. Ezek megjelenhetnek egy legördülő listában a keresés alatt, míg a felhasználó pedig esetlegesen befejezi az írást, és kiválasztja valamelyik gyakran használt keresőkifejezést közvetlenül. Az eredeti leírásakor a 2000-es évek közepén az Ajax általánosságban XML-t használt adatformátumként (az Ajax az Asynchronous Javascript and XML rövidítése[15], ám több fejlesztő JSON-t használt az adatátvitelre a szerver és a kliens között.[16]

A következő JavaScript-kód egy példa az XMLHttpRequest használatára az adatok JSON-lekérésével. (A szerver-oldali programozási rész kihagyva; úgy kell felállítani, hogy az url-en egy JSON-formátumú stringgel válaszoljon.)

var my_JSON_object = {};
var http_request = new XMLHttpRequest();
http_request.open("GET", url, true);
http_request.onreadystatechange = function () {
  var done = 4, ok = 200;
  if (http_request.readyState == done && http_request.status == ok) {
       my_JSON_object = JSON.parse(http_request.responseText);
  }
};
http_request.send(null);

Biztonsági problémák[szerkesztés | forrásszöveg szerkesztése]

Habár a JSON egy adatformátum, JavaScriptbe épülése számos biztonsági problémát vet fel, amennyiben JavaScript értelmezőt használunk (eval). Ezzel a módszerrel veszélyes szkript is lefuthat, ami gyakori probléma az internetről érkező JSON-adatok esetében. Bár van más módszer is a JSON adatok értelmezésére, egyszerű és gyors mivolta miatt gyakran használják. A következő fejezetben erre olvashatók példák.

JavaScript eval()[szerkesztés | forrásszöveg szerkesztése]

Mivel a JSON-formázott szöveg szintaktikailag érvényes JavaScript-kód, a JSON-értelmezésének egy egyszerű lehetséges eljárása a JavaScritbe beépített eval() függvény használata, amely a JavaScript-kifejezések kiértékelésére szolgál. A JSON-értelmező helyett magát a JavaScript interpretert használják a JSON adatok "lefuttatására", amely ezáltal natív JavaScript-objektumokat hoz létre. Mindazonáltal vannak olyan Unicode-karakterek, amelyek érvényesek JSON-ban, de érvénytelenek JavaScriptben, tehát extra escape-elés szükséges a JavaScript interpreterek használata előtt.[17]

Amennyiben elővigyázatossági intézkedések nélkül az eval() függvényt használja egy programkód, akkor biztonsági réseket okozhat az eval-os eljárás, ha az adat és a teljes JavaScriptes rendszer nem áll egyetlen, megbízható forrás ellenőrzése alatt. Például, ha az adat nem megbízható, akkor az érkező adat lehetséges, hogy egy JavaScriptes kódbeszúrásos támadást idéz elő. Emellett a bizalom ilyen megsértése okozhat adatlopást, autentikáció-hamisítást, és az adatok és erőforrások egyéb rossz használatát. A reguláris kifejezések használhatók az adatok validálására eval() esetén. Például a JSON-t definiáló RFC, az RFC 4627 a következő kódot javasolja a JSON eval()-ozása előtt használni (a „text” változó a bemeneti JSON-kód):[18]

var my_JSON_object = !(/[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test(
       text.replace(/"(\\.|[^"\\])*"/g, ''))) &&
   eval('(' + text + ')');

Egy új függvényt, a JSON.parse()-t is kifejlesztették, mint az eval() biztonságosabb alternatíváját. Specifikus célja JSON-adatok, nem pedig JavaScript-kódok értelmezése. Eredetileg az ECMAScript standard negyedik kiadásába tervezték beleírni,[19] ám ez nem történt meg. Az ötödik kiadásba azonban már belekerült,[20] a lejjebb listázott böngészők pedig már támogatják. A régebbiekhez egy kompatibilis JavaScript-könyvtár elérhető a JSON.org weblapon.

Natív kódolás és dekódolás a böngészőkben[szerkesztés | forrásszöveg szerkesztése]

Az újabb webböngészők vagy már rendelkeznek natív JSON kódolással és dekódolással, vagy ez már fejlesztés alatt áll. Ez kiküszöböli az eval() feljebb említett biztonsági problémáját, továbbá gyorsítja is, mivel nem használ értelmező funkciókat. A natív JSON általánosságban gyorsabb, mint a korábbiakban elterjedt JSON-értelmező könyvtárak. 2009 júniusában a következő böngészők rendelkeznek natív JSON-támogatással a JSON.parse() és a JSON.stringify() függvényeken keresztül:

Legalább 5 népszerű JavaScript-könyvtár használja a json.parse()-t, amennyiben az elérhető:

Objektumreferenciák[szerkesztés | forrásszöveg szerkesztése]

A JSON szabvány nem támogatja az objektumreferenciákat, de Dojo Toolkit bemutatja, hogy ezen konvenciók hogyan használhatók a standard JSON segítségével.[30][31] Nem-standard megoldások is léteznek, így például a Mozilla JavaScript Sharp Variables használata, habár ezt a funkcionalitást a Firefox 12-es verziójában eltávolították.[32]

Összehasonlítás más formátumokkal[szerkesztés | forrásszöveg szerkesztése]

A JSON-t az XML kis helyigényű alternatívájaként hirdetik, hiszen mindkettő széleskörűen támogatja a létrehozást, olvasást és írást a valós szituációkban, ahol gyakori a használatuk.[33] Az XML-en kívüli példák lehetnek az OGDL, a YAML és a CSV. Mindemellett a Google Protocol Buffers is betöltheti ezt a szerepet, habár nem adatcserére kifejlesztett nyelvről van szó.

XML[szerkesztés | forrásszöveg szerkesztése]

Az XML a strukturált adatok leírására és az objektumok szerializálására használt jelölőnyelv. Különböző XML-alapú protokollok léteznek, amelyek ugyanazon, JSON által is megvalósított adatstruktúrákat reprezentálják, ugyanazon adatcsere céljából. Amikor az adat XML-kódolású, általánosságban nagyobb méretű, mint JSON-os párja, leginkább a záró XML-címkék miatt. Mindazonáltal egy gzip-szerű tömörítő eljárás használata esetén már nagyon kicsi a különbség, ugyanis a gzip igencsak lecsökkenti az ismétlődő mintázatokkal rendelkező fájlok méretét.

Az XML-ben vannak alternatív módok a méret csökkentésére, ugyanis némely adatok lehetnek egyszerre gyermekként és attribútumként is megadva. Ez viszont bonyolíthatja az automatikus adatcserét, hiszen a különböző programoknak több különböző XML-implementációt kell tudniuk kezelni, ameddig nincs konkrétan megadva az implementáció típusa. Mindkét következő XML-implementáció ugyanazon információkat hordozza, mint korábbi JSON-os társa.

<szemely>
  <vezeteknev>Kovács</vezeteknev>
  <keresztnev>János</keresztnev>
  <kor>25</kor>
  <cim>
    <utcaHazszam>2. utca 21.</utcaHazszam>
    <varos>New York</varos>
    <allam>NY</allam>
    <iranyitoSzam>10021</iranyitoSzam>
  </cim>
  <telefonSzam>
    <telefon tipus="otthoni">212 555-1234</telefon>
    <telefon tipus="fax">646 555-4567</telefon>
  </telefonSzam>
</szemely>
<szemely vezetekNev="Kovács" keresztnev="János" kor="25">
  <cim utcaHazszam="2. utca 21." varos="New York" allam="NY" iranyitoszam="10021" />
  <telefonSzam>
     <telefon tipus="otthoni" szam="212 555-1234"/>
     <telefon tipus="fax"  szam="646 555-4567"/>
  </telefonSzam>
</szemely>

Emiatt az XML akár hasonlón kicsi méretű is lehet, mint ugyanazon tartalom JSON-nal kódolva. Széles skálája érhető el az XML-dokumentum-értelmezőknek, így például a Document Object Model, az XPath és az XSLT. Az XML továbbá stílusokat is kaphat az azonnali használatra a CSS segítségével. Az XHTML az XML egyik formája, tehát a tartalom ilyen formában is közvetíthető, ami által közvetlenül beleilleszthető a weboldalba kliens oldali kódolás nélkül.

Lásd még[szerkesztés | forrásszöveg szerkesztése]

Fordítás[szerkesztés | forrásszöveg szerkesztése]

Ez a szócikk részben vagy egészben a JSON című angol Wikipédia-szócikk fordításán alapul. Az eredeti cikk szerkesztőit annak laptörténete sorolja fel.

Jegyzetek[szerkesztés | forrásszöveg szerkesztése]

  1. Video: Douglas Crockford — The JSON Saga a Yahoo! Developer Networkön. A videóban Crockford a következőket mondja: „Nem állítom, hogy a JSON-t feltaláltam... Amit tettem, az az, hogy megtaláltam, elneveztem, leírtam, hogyan hasznos... Tehát az ötlet már ott volt egy ideje... Amit tettem, az, hogy adtam egy specifikációt és egy kis weboldalt [a JSON-nak].” ("I do not claim to have invented JSON... What I did was I found it, I named it, I described how it was useful... So the idea's been around there for a while. What I did was I gave it a specification, and a little website.")
  2. Yahoo!: Using JSON with Yahoo! Web services. [2007. október 11-i dátummal az eredetiből archiválva]. (Hozzáférés: 2009. július 3.)
  3. Google: Using JSON with Google Data APIs. (Hozzáférés: 2009. július 3.)
  4. Crockford, Douglas: Introducing JSON. json.org, 2009. május 28. (Hozzáférés: 2009. július 3.)
  5. Crockford, Douglas: JSON in JavaScript. json.org, 2008. július 9. (Hozzáférés: 2008. szeptember 8.)
  6. Standard ECMA-262
  7. Az RFC4627
  8. jquery - How to format a JSON date? - Stack Overflow
  9. Dates and JSON - Tales from the Evil Empire
  10. JSON Schema
  11. JSON Schema draft 3
  12. JSON Schema implementations
  13. JSV: JSON Schema Validator
  14. IANA | Application Media Types
  15. A W3Schools leírása
  16. Garrett, Jesse James: Ajax: A New Approach to Web Applications. Adaptive Path, 2005. február 18. (Hozzáférés: 2012. március 19.)
  17. JSON: The JavaScript subset that isn't. Magnus Holm. (Hozzáférés: 2011. május 16.)
  18. Sablon:Cite IETF
  19. Crockford, Douglas: JSON: The Fat-Free Alternative to XML, 2006. december 6. (Hozzáférés: 2009. július 3.)
  20. ECMAScript Fifth Edition. (Hozzáférés: 2011. március 18.)
  21. Using Native JSON, 2009. június 30. (Hozzáférés: 2009. július 3.)
  22. Barsan, Corneliu: Native JSON in IE8, 2008. szeptember 10. (Hozzáférés: 2009. július 3.)
  23. Web specifications supported in Opera Presto 2.5, 2010. március 10. (Hozzáférés: 2010. március 29.)
  24. Hunt, Oliver: Implement ES 3.1 JSON object, 2009. június 22. (Hozzáférés: 2009. július 3.)
  25. YUI 2: JSON utility, 2009. szeptember 1. (Hozzáférés: 2009. október 22.)
  26. Learn JSON, 2010. április 7. (Hozzáférés: 2010. április 7.)
  27. Ticket #4429, 2009. május 22. (Hozzáférés: 2009. július 3.)
  28. Ticket #8111, 2009. június 15. (Hozzáférés: 2009. július 3.)
  29. Ticket 419, 2008. október 11. (Hozzáférés: 2009. július 3.)
  30. Zyp, Kris: JSON referencing in Dojo, 2008. június 17. (Hozzáférés: 2009. július 3.)
  31. von Gaza, Tys: JSON referencing in jQuery, 2010. december 7. (Hozzáférés: 2010. december 7.)[halott link]
  32. Sharp variables in JavaScript. (Hozzáférés: 2012. április 21.)
  33. JSON: The Fat-Free Alternative to XML. json.org. (Hozzáférés: 2011. március 14.)

Külső hivatkozások[szerkesztés | forrásszöveg szerkesztése]