JSON: mi ez, adatszerkezet és működési elv

Mi az a JSON?

JSON — egy szöveges formátum strukturált adatok megjelenítésére, a JavaScript szintaxisa alapján. Annak ellenére, hogy a JavaScriptből származik, a formátum teljesen független a nyelvtől — elemzők és szerializálók minden népszerű programozási nyelvhez léteznek.

A JSON története a 2000-es évek elején kezdődött, amikor Douglas Crockford kiválasztotta a JavaScript szintaxis egy részhalmazát az adatcseréhez. 2013-ban a formátumot ECMA-404, később ISO/IEC 21778:2017 szabványosították. A név a JavaScript Object Notation rövidítése.

A JSON fő előnye a minimalista szintaxis. Az adatok leírásához csak hat típust használnak: string, szám, boolean, null, tömb és objektum. Ez elegendő bármilyen, alkalmazásokban használt adatszerkezet megjelenítéséhez.

Hol használják a JSON-t

• REST API — elsődleges formátum a szerver és kliens közötti kérésekhez és válaszokhoz
• Konfigurációs fájlok — package.json, tsconfig.json, .prettierrc
• Adatbázisok — MongoDB, PostgreSQL (JSONB), Firebase Firestore
• Mobilalkalmazások — beállítások tárolása, adatok gyorsítótárazása
• Webtechnológiák — WebSocket, Server-Sent Events, localStorage

A JSON szintaxisa és adattípusai

A JSON szintaxisa rendkívül egyszerű: az adatok kulcs-érték párokként jelennek meg, ahol a kulcs egy string dupla idézőjelek között, az érték pedig a hat alaptípus egyike. Az objektumok kapcsos zárójelekbe, a tömbök szögletes zárójelekbe kerülnek. A stringek kötelezően dupla idézőjeleket használnak, az egyszeres idézőjelek nem megengedettek.

A számok a JSON-ban lehetnek egészek vagy lebegőpontosak, pozitívak vagy negatívak, exponenciális jelöléssel. A logikai értékeket a true és false literálok, az érték hiányát a null jelöli. A tömbök bármilyen típusú érték rendezett halmazát tartalmazzák, beleértve az egymásba ágyazott tömböket és objektumokat.

{
  "name": "JSON",
  "type": "text",
  "version": 2024,
  "flexible": true,
  "extensions": null,
  "languages": [
    "JavaScript",
    "Python",
    "Java"
  ],
  "nested": {
    "info": "beágyazás támogatása"
  }
}

JSON a REST API-ban

JSON az elsődleges adatcsere-formátum a REST API számára mobil- és webfejlesztésben. A szerver JSON-t küld a válasz törzsében, a kliens — a kérés törzsében. A szabványos Content-Type fejléc a JSON számára application/json.

A modern REST API-k a JSON-t használják minden típusú adat átvitelére: az egyszerű listáktól a komplex, egymásba ágyazott, entitások közötti kapcsolatokkal rendelkező szerkezetekig. A klienskönyvtár (pl. Axios JavaScriptben vagy Retrofit Androidon) automatikusan szerializálja és deszerializálja a JSON-t, megkímélve a fejlesztőt a manuális elemzéstől.

A JSON fontos előnye a REST API-ban a részleges adatátvitel (partial response) lehetősége a kérés paraméterein keresztül, valamint az egymásba ágyazott erőforrások támogatása további szerverlekérések nélkül.

JSON értelmezés mobil platformokon

JSON értelmezés mobil platformokon beépített eszközökkel történik. Az Android a Google Gson vagy a Square Moshi könyvtárait, az iOS a Codable protokollt használja a JSONDecoder-rel. Minden platform kényelmes eszközöket biztosít a JSON natív objektumokká történő konvertálásához és fordítva.

JSON Androidon (Kotlin)

Androidon a Gson vagy Moshi használata népszerű. Elég egy data class-t definiálni @SerializedName annotációkkal és meghívni a fromJson-t a deszerializációhoz. A könyvtár automatikusan hozzárendeli a JSON-ban lévő mezőneveket az osztály mezőihez.

import com.google.gson.Gson
import com.google.gson.annotations.SerializedName

data class User(
    @SerializedName("id") val id: Int,
    @SerializedName("name") val name: String,
    @SerializedName("email") val email: String
)

fun parseJson(jsonString: String): User {
    val gson = Gson()
    return gson.fromJson(jsonString, User::class.java)
}

JSON iOS-en (Swift)

iOS-en a beépített Codable protokollt használják a JSONDecoder-rel. Az adatszerkezetet struct-ként deklarálják a Codable protokollal, majd a JSON egy sorral elemezhető. A JSONEncoder végrehajtja a fordított szerializációt — az objektumot JSON-ba konvertálja a szerverre küldéshez.

import Foundation

struct User: Codable {
    let id: Int
    let name: String
    let email: String
}

func parseJSON(from data: Data) throws -> User {
    let decoder = JSONDecoder()
    return try decoder.decode(User.self, from: data)
}

JSON vs XML: formátumok összehasonlítása

JSON és XML — két elsődleges formátum strukturált adatok továbbítására. A JSON az egyszerűségben és teljesítményben, az XML a szigoriságban és érvényesítésben jeleskedik. A köztük lévő választás a projekt követelményeitől függ: a REST API-hoz gyakrabban választják a JSON-t, összetett sémákkal rendelkező dokumentumokhoz az XML-t.

Az XML minden elemhez záró címkéket igényel, ami 2-3-szorosára növeli az adatméretet a JSON-hoz képest. Ugyanakkor az XML támogatja a névtereket, XSD sémákat, attribútumokat és XSLT transzformációt, ami erősebbé teszi a dokumentum-munkafolyamatok és vállalati rendszerintegráció feladataihoz.

Példák a JSON használatára

Példák bemutatják a tipikus JSON-műveleteket a mobilfejlesztésben: API-válaszok elemzése, JSON létrehozása küldéshez és egymásba ágyazott szerkezetek feldolgozása. Ezen minták megértése elengedhetetlen minden mobilalkalmazás-fejlesztő számára.

Objektum szerializációja JSON-ba

JavaScriptben a JSON.stringify egy objektumot JSON stringgé alakít. A második argumentum lehet egy kulcstömb a szelektív szerializációhoz vagy egy helyettesítő függvény. A harmadik argumentum a behúzást állítja be a formázáshoz.

interface Order {
  id: string;
  items: OrderItem[];
  total: number;
  createdAt: string;
}

const order: Order = {
  id: 'ord_001',
  items: [{ product: 'phone', quantity: 2 }],
  total: 1599.98,
  createdAt: '2026-07-03T10:00:00Z'
};

const jsonString = JSON.stringify(order, null, 2);

Egymásba ágyazott JSON elemzése

Kotlinban a Moshi könyvtárral az egymásba ágyazott JSON objektumok egymásba ágyazott data class-okon keresztül dolgozhatók fel. A @Json annotáció jelzi a mező nevét a JSON-ban, ha az eltér az osztály tulajdonságának nevétől. A tömbök List-ként jelennek meg az elem típusával.

import com.squareup.moshi.Moshi
import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory

data class ApiResponse(
    val status: String,
    val data: List<Product>,
    val pagination: Pagination
)

data class Product(
    val id: Int,
    val title: String,
    val price: Double
)

data class Pagination(
    val page: Int,
    val total: Int
)

val moshi = Moshi.Builder()
    .add(KotlinJsonAdapterFactory())
    .build()

JSON Séma: szerkezeti érvényesítés

JSON Séma — egy nyelv a JSON dokumentum szerkezetének leírására, analóg az XML XSD-jével. A JSON Séma segítségével kötelező mezők, adattípusok, értéktartományok, string minták és egymásba ágyazott szerkezet állíthatók be. A séma szerinti érvényesítés az adathibákat még az alkalmazásban történő feldolgozás előtt észleli.

A JSON Sémát széles körben használják az OpenAPI-ban (Swagger) a REST API dokumentálásához, a beviteli adatok érvényesítő űrlapjaiban és a tesztelésben. A sémafájl maga is egy JSON dokumentum, ami lehetővé teszi a szabványos JSON-elemzők használatát az olvasásához. Online érvényesítők és könyvtárak léteznek minden népszerű programozási nyelvhez.

A mobilfejlesztésben a JSON Sémát a szerverválaszok tesztelési fázisban történő érvényesítésére és a konfigurációs fájlok ellenőrzésére használják. Az olyan könyvtárak, mint a network-validator Androidon és a json-schema-validator, lehetővé teszik az érvényesítés közvetlen beépítését a fejlesztési folyamatba, megelőzve a hibákat a korai szakaszokban.