16. februar 2026

JSON metoder, toJSON

Lad os sige vi har en kompleks objekt, som vi gerne vil konvertere til en streng. Det kan vi gøre for at sende det over en netværk, eller bare for at udskrive det for logføring.

Selvfølgelig skal en sådan streng indeholde alle vigtige egenskaber.

Vi kunne implementere konverteringen sådan her:

let user = {
  name: "John",
  age: 30,

  toString() {
    return `{name: "${this.name}", age: ${this.age}}`;
  }
};

alert(user); // {name: "John", age: 30}

…Men her, bliver nye egenskaber tilføjet, gamle egenskaber omdøbt og fjernet. Samtidig kan en opdatering af toString hver gang blive en omstændig proces. Vi kunne prøve at loop over egenskaberne, men hvad hvis objektet er komplekst og har objekter i egenskaber? Vi ville have brug for at implementere deres konvertering også.

Heldigvis er der en metode til at håndtere alt dette. Denne opgave er løst for os.

JSON.stringify

JSON (JavaScript Object Notation) er et generisk format til at repræsentere værdier og objekter. Den er beskrevet i RFC 4627 standarden. Den blev oprindeligt lavet for JavaScript, men mange andre sprog har biblioteker til at håndtere den. Så det er nemt at bruge JSON for data exchange når klienten bruger JavaScript og serveren er skrevet på Ruby/PHP/Java/Whatever.

JavaScript har metoder:

  • JSON.stringify for at konvertere objekter til JSON.
  • JSON.parse for at konvertere JSON tilbage til et objekt.

For eksempel, her bruges JSON.stringify på et objekt med en student:

let student = {
  name: 'John',
  age: 30,
  isAdmin: false,
  courses: ['html', 'css', 'js'],
  spouse: null
};

let json = JSON.stringify(student);

alert(typeof json); // vi har en streng!

alert(json);
/* JSON-encoded objekt:
{
  "name": "John",
  "age": 30,
  "isAdmin": false,
  "courses": ["html", "css", "js"],
  "spouse": null
}
*/

Metoden JSON.stringify(student) tager objektet og konverterer det til en streng.

Den resulterende json streng kaldes et JSON-encoded eller serialized eller stringified eller marshalled objekt. Vi er klar til at sende det over netværket eller gemme det i en database.

Bemærk at en JSON objekt har flere vigtige forskel på objekter:

  • Strenge bruger dobbelte anførselstegn. Ingen enkelte anførselstegn eller backticks i JSON. Så 'John' bliver "John".
  • Objekts property navne er også dobbelte anførselstegn. Det er obligatorisk. Så age:30 bliver "age":30.

JSON.stringify kan også bruges på primitiver.

JSON understøtter følgende datatyper:

  • Objekter { ... }
  • Arrays [ ... ]
  • Primitiver:
    • strenge,
    • tal,
    • booleske værdier true/false,
    • null.

For eksempel:

// et tal i JSON er bare et tal
alert( JSON.stringify(1) ) // 1

// en streng i JSON er stadig en streng, men dobbelte anførselstegn
alert( JSON.stringify('test') ) // "test"

alert( JSON.stringify(true) ); // true

alert( JSON.stringify([1, 2, 3]) ); // [1,2,3]

JSON er en specifiktation der alene fokuserer på data. Så nogle JavaScript-specifikke objekters egenskaber er ikke inkluderet i JSON.stringify.

Namely:

  • Funktioner (metoder).
  • Symbolske nøgler og værdier.
  • Egenskaber der gemmer undefined.
let user = {
  sayHi() { // ignoreret
    alert("Hello");
  },
  [Symbol("id")]: 123, // ignoreret
  something: undefined // ignoreret
};

alert( JSON.stringify(user) ); // {} (tomt objekt)

Normalt er det fint. Hvis det ikke er hvad vi ønsker, så vil vi snart se hvordan vi kan tilpasse processen.

Det store træk er at nøstede objekter understøttes og konverteres automatisk.

For eksempel:

let meetup = {
  title: "Konference",
  room: {
    number: 23,
    participants: ["john", "ann"]
  }
};

alert( JSON.stringify(meetup) );
/* Hele strukturen bliver stringified:
{
  "title":"Konference",
  "room":{"number":23,"participants":["john","ann"]},
}
*/

Den vigtige begrænsning er at der ikke må være en cirkulær referencer.

For eksempel:

let room = {
  number: 23
};

let meetup = {
  title: "Konference",
  participants: ["john", "ann"]
};

meetup.place = room;       // meetup refererer til room
room.occupiedBy = meetup; // room refererer til meetup

JSON.stringify(meetup); // Error: Converting circular structure to JSON

Her fejler konverteringen, fordi der er en cirkulær referencer: room.occupiedBy refererer til meetup, og meetup.place refererer til room:

Udeluk og transformer: replacer

Den fulde syntaks for JSON.stringify er:

let json = JSON.stringify(value[, replacer, space])
value
Den værdi der skal konverteres.
replacer
En array af egenskaber der skal konverteres eller en mapping funktion function(key, value).
space
Antallet af mellemrum der skal bruges for formatering.

De fleste gange bruges JSON.stringify kun med det første argument. Men hvis vi har brug for at fine-tune konverteringsprocessen, så kan vi bruge den anden argument til JSON.stringify.

Hvis vi sender en array af egenskaber til den, så bliver kun disse egenskaber kodet.

For eksempel:

let room = {
  number: 23
};

let meetup = {
  title: "Konference",
  participants: [{name: "John"}, {name: "Alice"}],
  place: room // meetup refererer til room
};

room.occupiedBy = meetup; // room refererer til meetup

alert( JSON.stringify(meetup, ['title', 'participants']) );
// {"title":"Konference","participants":[{},{}]}

Her er vi sandsynligvis lidt for strikse. Listen med egenskaber bliver anvendt på hele objekstrukturen. Så objekterne inde i participants er tomme, fordi name ikke er med på listen.

Lad os inkludere hver egenskab i listen, undtagen room.occupiedBy der ville forårsage en cirkulær referance:

let room = {
  number: 23
};

let meetup = {
  title: "Konference",
  participants: [{name: "John"}, {name: "Alice"}],
  place: room // meetup refererer til room
};

room.occupiedBy = meetup; // room refererer til meetup

alert( JSON.stringify(meetup, ['title', 'participants', 'place', 'name', 'number']) );
/*
{
  "title":"Konference",
  "participants":[{"name":"John"},{"name":"Alice"}],
  "place":{"number":23}
}
*/

Nu bliver alt, undtagen occupiedBy, kodet. Men listen med egenskaber er meget lang.

Fortjusligtvis kan vi bruge en funktion i stedet for en array som replacer.

Denne funktion bliver kaldt for hver (key, value) par og skal returnere den “omplacerede” værdi, der vil blive brugt i stedet for den originale værdi. Eller undefined hvis værdien skal blive ignoreret.

I vores tilfælde kan vi returnere value “som det er” for alt, undtagen occupiedBy. For at ignorere occupiedBy, returnerer koden under undefined: