JSON-validator

Hvad er JSON-validering?

JSON (JavaScript Object Notation) er et bredt anvendt, letvægts dataudvekslingsformat, designet til både at være letlæseligt for mennesker og nemt for maskiner at analysere og generere. Dets primære formål er at repræsentere strukturerede data—objekter, arrays, strenge, tal, booleaner og null-værdier—på en sprogneutral måde.

JSON-validering er processen med programmatisk at verificere, at et JSON-dokument både er syntaktisk og strukturelt korrekt. Dette indebærer at kontrollere to hovedaspekter:

• Syntaktisk validering: Sikring af, at råteksten følger den formelle grammatik som defineret af ECMA-404 JSON-specifikationen. Parsere i de fleste moderne programmeringssprog (f.eks. JSON.parse() i JavaScript, json.loads() i Python, JSONDecoder i Java) forventer gyldig syntaks og vil kaste fejl, hvis inputtet er fejlbehæftet.
• Strukturel (Skema) Validering: Udover syntaks kontrollerer skemavalidering, at JSON-dataene matcher en forventet struktur, herunder datatyper, påkrævede egenskaber, værdibegrænsninger samt indlejrede objekter/arrays. Skemavalidering udføres typisk ved hjælp af JSON Schema, som definerer regler for, hvad der betragtes som gyldige data.

Hvorfor validere JSON?

JSON-validering er afgørende, når data serialiseres til overførsel, lagring eller kommunikation mellem tjenester. Vigtige årsager inkluderer:

• Fejlforebyggelse: Registrer og rapporter syntaksfejl (f.eks. manglende kommaer, ubalancerede parenteser, ulovlige tegn) tidligt – inden data behandles.
• Dataintegritet og sikkerhed: Afvis forkert formaterede eller skadelige JSON-payloads for at forhindre backend-nedbrud, injektionsangreb eller datakorruption.
• Typsikkerhed: Sikr streng typning—og dermed for eksempel, at et felt forventes at være en boolesk værdi og ikke sendes som en tekststreng, eller at UUID’er, e-mails og tal følger det korrekte format.
• Tværsproglig kompatibilitet: Sikr, at JSON genereret i ét miljø (f.eks. Node.js) kan anvendes sikkert i et andet (f.eks. Python, Go, Java), og undgå fejl ved serialisering og deserialisering.
• Vedligeholdelse og Robusthed: Validerede datastrukturer forbedrer sporbarhed og reducerer risikoen for fejl, der er svære at fejlfinde i konfigurationsfiler, logfiler eller API-anmodninger/-svar.
• Privatliv og Sikkerhed: Validering kan udføres fuldstændigt på klientsiden (i browseren), hvilket forhindrer, at rå eller følsomme data forlader brugerens enhed til validering.

Almindelige JSON-valideringsfejl (med detaljerede eksempler)

Uden citationstegn nøgler

Alle nøgler i JSON-objekter skal være dobbeltanførte strenge.

{ navn: "Alice" }

{ "name": "Alice" }

Mange JSON-lignende formater (f.eks. JavaScript objekt-literal) tillader nøgler uden anførselstegn, men standard JSON gør ikke.

Enkeltanførelsestegn

JSON-strenge skal kun bruge dobbelte anførselstegn; enkelte anførselstegn er ikke tilladt.

{ 'navn': 'Bob' }

{ "name": "Bob" }

Brug af enkelte anførselstegn vil føre til parserfejl i alle overensstemmende JSON-biblioteker.

Efterfølgende kommaer

Ingen komma efter det sidste element i et objekt eller array.

{
  "a": 1,
  "b": 2,
}

{
  "a": 1,
  "b": 2
}

Slutkommaer kan fungere i JavaScript, men ikke i strenge JSON-parsere.

Forkert undvigelse af tegn

Citater og specialtegn inden i strenge skal undslippes med en backslash.

{ "quote": "Tom sagde \"hej\"" }

{ "quote": "Tom sagde \"hej\"" }

Andre escape-sekvenser inkluderer \\ for omvendt skråstreg, \n for linjeskift og \t for tabulatorer.

Forkerte datatyper

Strenge bør ikke bruges til tal, booleske værdier eller null.

{ "enabled": "sand", "count": "10" }

{ "aktiveret": true, "antal": 10 }

JSON skelner mellem booleske værdier, tal og tekststrenge—sørg for at bruge den korrekte type.

Ikke-primitive nøgler

Nøgler i JSON-objekter skal altid være strenge; du kan ikke bruge tal, booleske værdier eller andre typer som nøgler.

{ 123: "abc" }

{ "123": "abc" }

Dublerede Nøgler

Selvom det er tilladt ifølge JSON-specifikationen, er dublerede nøgler en almindelig kilde til fejl.

{ "name": "Alice", "name": "Bob" }

De fleste parsere beholder kun den sidste værdi ("Bob") og kasserer tidligere værdier uden varsel.

Brug af kommentarer

Standard JSON tillader ikke kommentarer, selvom nogle redaktører understøtter dem.

{
  // Brugerinformation
  "name": "Alice"
}

{
  "name": "Alice"
}

Skema Validering: Sikring af Struktur og Datatyper

JSON Schema er en effektiv standard til at definere og validere den forventede struktur af JSON-dokumenter. Den giver dig mulighed for at specificere:

• Obligatoriske felter (`required`)
• Datatyper (`type`: tekst, tal, boolesk, objekt, array, nul)
• Strengformater (`format`: e-mail, uuid, dato-tid, osv.)
• Mønster matching for strenge (`pattern`)
• Talintervaller (`minimum`, `maksimum`)
• Array-længde og elementvalidering (`minItems`, `maxItems`, `items`)
• Indlejret validering for objekter og arrays
• Enum-begrænsninger (`enum`)

Eksempel: Bruger Skema (Udkast-07)

{
  "type": "object",
  "properties": {
    "id":    { "type": "string", "format": "uuid" },
    "name":  { "type": "string", "minLength": 1 },
    "email": { "type": "string", "format": "email" },
    "is_active": { "type": "boolean" }
  },
  "required": ["id", "name", "email"],
  "additionalProperties": false
}

Hvad dette håndhæver:

• id skal være en gyldig UUID-streng.
• navn skal være en ikke-tom streng.
• e-mail skal stemme overens med standard e-mailformat.
• is_active (valgfri) skal være en boolesk værdi.
• Ingen andre egenskaber end dem, der er defineret ovenfor, er tilladt.

Praktisk Eksempel: Validering af Stripe API-svar

Forestil dig, at du modtager JSON-svar fra Stripe API'et (f.eks. PaymentIntent). Skemavalidering sikrer, at du aldrig behandler ufuldstændige eller forkert typede data.

{
  "type": "object",
  "properties": {
    "id":      { "type": "string", "pattern": "^pi_" },
    "object":  { "type": "string", "const": "payment_intent" },
    "amount":  { "type": "integer", "minimum": 1 },
    "currency":{ "type": "string", "minLength": 3, "maxLength": 3 },
    "status":  { "type": "string", "enum": [
      "kræver_betalingsmetode",
      "kræver_bekræftelse",
      "behandler",
      "lykkedes",
      "annulleret"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• id skal starte med "pi_"
• objekt skal altid være "payment_intent"
• beløbet skal være et helt tal større end eller lig med 1
• valuta skal være en trefuld streng (f.eks. "usd", "eur")
• status skal være en af de angivne værdier

Fordele

• Tidlig fejlregistrering: Opdag kritiske API-ændringer eller ufuldstændige data, før de påvirker din forretningslogik.
• Automatiseret Testning: Brug skemaer i CI/CD-pipelines til at validere både reale og simulerede svar.
• Tværgående konsistens: Standardiser datakontrakter mellem frontend, backend og tredjeparts-API'er.

Korrekt JSON-validering – der dækker både syntaks og skema – forhindrer skjulte fejl, sikrer bedste praksis og beskytter dine applikationer mod fejlbehæftet eller skadelig input. Uanset om det bruges i konfigurationsfiler, API-payloads eller mellemservices kommunikation, er robust validering grundlæggende for moderne softwaresystemer.

Privatliv & Sikkerhed

Al validering og skemakontrol kører lokalt i din browser. Ingen data uploades eller logges. Dit JSON forbliver helt privat.

Kodeeksempler til JSON-validering

Se, hvordan du validerer JSON i forskellige programmeringssprog ved hjælp af indbyggede biblioteker eller populære frameworks. Disse eksempler viser både syntaksvalidering og skema-validering.

const jsonString = '{"name":"Alice","age":30}';
try {
  const obj = JSON.parse(jsonString);
  console.log("Valid JSON:", obj);
} catch (e) {
  console.error("Invalid JSON!", e.message);
}

const Ajv = require("ajv");
const ajv = new Ajv();
const schema = { type: "object", properties: { age: { type: "integer" } }, required: ["age"] };
const data = { age: 30 };
const validate = ajv.compile(schema);
console.log(validate(data) ? "Valid!" : ajv.errorsText(validate.errors));

import json
try:
    obj = json.loads('{"name":"Alice","age":30}')
    print("Valid JSON:", obj)
except json.JSONDecodeError as e:
    print("Invalid JSON:", e)

import json, jsonschema
schema = {
    "type": "object",
    "properties": { "age": { "type": "integer" } },
    "required": ["age"]
}
data = {"age": 30}
try:
    jsonschema.validate(data, schema)
    print("Valid!")
except jsonschema.ValidationError as e:
    print("Schema validation error:", e)

package main
import (
  "encoding/json"
  "fmt"
)
func main() {
  data := []byte(`{"name":"Alice","age":30}`)
  var obj map[string]interface{}
  if err := json.Unmarshal(data, &obj); err != nil {
    fmt.Println("Invalid JSON:", err)
  } else {
    fmt.Println("Valid JSON:", obj)
  }
}

import com.fasterxml.jackson.databind.ObjectMapper;
public class Main {
  public static void main(String[] args) {
    String json = "{"name":"Alice","age":30}";
    try {
      Object obj = new ObjectMapper().readTree(json);
      System.out.println("Valid JSON: " + obj);
    } catch (Exception e) {
      System.out.println("Invalid JSON: " + e.getMessage());
    }
  }
}

using System;
using System.Text.Json;
class Program {
  static void Main() {
    string json = "{"name":"Alice","age":30}";
    try {
      var doc = JsonDocument.Parse(json);
      Console.WriteLine("Valid JSON!");
    } catch (JsonException e) {
      Console.WriteLine("Invalid JSON: " + e.Message);
    }
  }
}

<?php
$json = '{"name":"Alice","age":30}';
$obj = json_decode($json);
if (json_last_error() === JSON_ERROR_NONE) {
  echo "Valid JSON";
} else {
  echo "Invalid JSON: " . json_last_error_msg();
}

require 'json'
begin
  obj = JSON.parse('{"name":"Alice","age":30}')
  puts "Valid JSON!"
rescue JSON::ParserError => e
  puts "Invalid JSON: #{e.message}"
end

echo '{"name":"Alice","age":30}' | jq empty && echo "Valid" || echo "Invalid"

fn main() {
  let data = r#"{"name":"Alice","age":30}"#;
  match serde_json::from_str::<serde_json::Value>(data) {
    Ok(_) => println!("Valid JSON!"),
    Err(e) => println!("Invalid JSON: {}", e),
  }
}

import org.json.JSONObject
fun main() {
  try {
    val obj = JSONObject("{\"name\":\"Alice\",\"age\":30}")
    println("Valid JSON: $obj")
  } catch (e: Exception) {
    println("Invalid JSON: ${e.message}")
  }
}

import Foundation
let json = "{\"name\":\"Alice\",\"age\":30}"
if let data = json.data(using: .utf8) {
  do {
    let _ = try JSONSerialization.jsonObject(with: data)
    print("Valid JSON!")
  } catch {
    print("Invalid JSON: \(error)")
  }
}

const jsonString = '{"name":"Alice","age":30}';
try {
  const obj = JSON.parse(jsonString);
  console.log("Valid JSON:", obj);
} catch (e) {
  console.error("Invalid JSON!", e.message);
}

SELECT '{"name":"Alice","age":30}'::jsonb; -- Will error if not valid JSON

SELECT JSON_VALID('{"name":"Alice","age":30}');

$json = '{"name":"Alice","age":30}'
try {
  $obj = $json | ConvertFrom-Json
  Write-Output "Valid JSON!"
} catch {
  Write-Output "Invalid JSON: $($_.Exception.Message)"
}

use JSON;
my $str = '{"name":"Alice","age":30}';
eval { decode_json($str) };
print $@ ? "Invalid JSON: $@" : "Valid JSON!";

import 'dart:convert';
void main() {
  const jsonString = '{"name":"Alice","age":30}';
  try {
    final obj = jsonDecode(jsonString);
    print('Valid JSON: $obj');
  } catch (e) {
    print('Invalid JSON: $e');
  }
}

json = ~s({"name":"Alice","age":30})
case Jason.decode(json) do
  {:ok, _} -> IO.puts("Valid JSON!")
  {:error, err} -> IO.puts("Invalid JSON: #{err}")
end

import play.api.libs.json._
object Main extends App {
  val str = """{"name":"Alice","age":30}"""
  try {
    val json = Json.parse(str)
    println("Valid JSON!")
  } catch {
    case e: Exception => println("Invalid JSON: " + e.getMessage)
  }
}

Om dette værktøj