JSON: vad är det, datastruktur och funktionsprincip

Vad är JSON?

JSON — är ett textformat för representation av strukturerad data, baserat på JavaScript-syntax. Trots sitt ursprung från JavaScript är formatet helt språkoberoende — parsrar och serialiserare finns för alla populära programmeringsspråk.

JSONs historia började i början av 2000-talet, när Douglas Crockford separerade en delmängd av JavaScript-syntax för datautbyte. År 2013 standardiserades formatet som ECMA-404 och senare som ISO/IEC 21778:2017. Namnet står för JavaScript Object Notation.

Den främsta fördelen med JSON är dess minimalistiska syntax. För att beskriva data används endast sex typer: sträng, nummer, boolean, null, array och objekt. Detta är tillräckligt för att representera alla datastrukturer som används i applikationer.

Var används JSON

• REST API — primärt format för förfrågningar och svar mellan server och klient
• Konfigurationsfiler — package.json, tsconfig.json, .prettierrc
• Databaser — MongoDB, PostgreSQL (JSONB), Firebase Firestore
• Mobilappar — lagring av inställningar, cachelagring av data
• Webbteknologier — WebSocket, Server-Sent Events, localStorage

JSON-syntax och datatyper

JSON-syntax är extremt enkel: data representeras som nyckel-värdepar, där nyckeln är en sträng inom dubbla citattecken och värdet är en av de sex grundläggande typerna. Objekt omges av klamrar, arrayer av hakparenteser. Strängar använder obligatoriskt dubbla citattecken, enkla citattecken är inte tillåtna.

Tal i JSON kan vara heltal eller flyttal, positiva eller negativa, med exponentiell notation. Booleska värden representeras av true och false, och frånvaro av värde representeras av null. Arrayer innehåller en ordnad samling värden av vilken typ som helst, inklusive nästlade arrayer och objekt.

{
  "name": "JSON",
  "type": "text",
  "version": 2024,
  "flexible": true,
  "extensions": null,
  "languages": [
    "JavaScript",
    "Python",
    "Java"
  ],
  "nested": {
    "info": "stöd för nästling"
  }
}

JSON i REST API

JSON är det primära datautbytesformatet för REST API inom mobil- och webbutveckling. Servern skickar JSON i svarskroppen, klienten — i förfråganskroppen. Standardrubriken Content-Type för JSON är application/json.

Moderna REST API använder JSON för att överföra alla typer av data: från enkla listor till komplexa nästlade strukturer med relationer mellan entiteter. Klientbiblioteket (t.ex. Axios i JavaScript eller Retrofit på Android) serialiserar och deserialiserar automatiskt JSON, vilket befriar utvecklaren från manuell tolkning.

En viktig fördel med JSON i REST API är möjligheten till partiell dataöverföring (partial response) via förfrågeparametrar, samt stöd för nästlade resurser utan ytterligare förfrågningar till servern.

JSON-tolkning på mobila plattformar

JSON-tolkning på mobila plattformar utförs med inbyggda verktyg. Android använder biblioteken Gson från Google eller Moshi från Square, iOS använder Codable-protokollet med JSONDecoder. Varje plattform tillhandahåller praktiska verktyg för att konvertera JSON till inbyggda objekt och vice versa.

JSON på Android (Kotlin)

På Android är tillvägagångssättet med Gson eller Moshi populärt. Det räcker att definiera en data class med @SerializedName-annotationer och anropa fromJson för deserialisering. Biblioteket matchar automatiskt fältnamn i JSON med klassfält.

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 på iOS (Swift)

På iOS används det inbyggda Codable-protokollet med JSONDecoder. Datastrukturen deklareras som en struct med Codable-protokollet, varefter JSON tolkas med en rad. JSONEncoder utför omvänd serialisering — konverterar objektet till JSON för sändning till servern.

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: jämförelse av format

JSON och XML — två primära format för att överföra strukturerad data. JSON vinner i enkelhet och prestanda, XML i noggrannhet och validering. Valet mellan dem beror på projektkraven: för REST API väljs oftare JSON, för komplexa dokument med scheman — XML.

XML kräver stängningstaggar för varje element, vilket ökar datastorleken 2-3 gånger jämfört med JSON. Samtidigt stöder XML namnrymder, XSD-scheman, attribut och XSLT-transformering, vilket gör det kraftfullare för dokumentflöde och integration av företagssystem.

Exempel på arbete med JSON

Exempel visar typiska JSON-operationer inom mobilutveckling: tolkning av API-svar, skapande av JSON för sändning och bearbetning av nästlade strukturer. Förståelse av dessa mönster är nödvändig för varje mobilapputvecklare.

Serialisering av objekt till JSON

I JavaScript konverterar JSON.stringify ett objekt till en JSON-sträng. Det andra argumentet kan vara en array av nycklar för selektiv serialisering eller en ersättningsfunktion. Det tredje argumentet anger indrag för formatering.

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);

Tolkning av nästlad JSON

I Kotlin med Moshi-biblioteket bearbetas nästlade JSON-objekt genom nästlade data class-objekt. @Json-annotationen anger fältnamnet i JSON om det skiljer sig från egenskapsnamnet i klassen. Arrayer representeras som List med elementtypen.

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 Schema: strukturvalidering

JSON Schema — är ett språk för att beskriva strukturen av ett JSON-dokument, analogt med XSD för XML. Med JSON Schema kan obligatoriska fält, datatyper, värdeintervall, strängmönster och nästlad struktur anges. Validering enligt schemat upptäcker datafel innan de bearbetas i applikationen.

JSON Schema används flitigt i OpenAPI (Swagger) för att dokumentera REST API, i formulär för inmatningsvalidering och vid testning. Schemafilen är själv ett JSON-dokument, vilket möjliggör användning av standard JSON-parsrar för att läsa den. Det finns online-validerare och bibliotek för alla populära programmeringsspråk.

Inom mobilutveckling används JSON Schema för att validera serversvar i testfasen och för att kontrollera konfigurationsfiler. Bibliotek som network-validator på Android och json-schema-validator gör det möjligt att bädda in validering direkt i utvecklingsprocessen, vilket förhindrar fel i tidiga skeden.