JSON-validering

Hva er JSON-validering?

JSON (JavaScript Object Notation) er et mye brukt, lettvektig datautvekslingsformat, designet for å være både lett å lese for mennesker og enkelt for maskiner å analysere og generere. Hovedformålet er å representere strukturert data — objekter, matriser, strenger, tall, boolske verdier og null — på en språkuavhengig måte.

JSON-validering er prosessen med å programmessig verifisere at et JSON-dokument er både syntaktisk og strukturelt korrekt. Dette innebærer å kontrollere to hovedaspekter:

• Syntaktisk validering: Sikrer at råteksten følger den formelle grammatikken som er definert i ECMA-404 JSON-spesifikasjonen. Parserne i de fleste moderne programmeringsspråk (for eksempel JSON.parse() i JavaScript, json.loads() i Python, JSONDecoder i Java) forventer gyldig syntaks og vil gi feil hvis inndataene er feilformatert.
• Strukturell (Schema) Validering: Utover syntaks sjekker skjema-validering at JSON-dataene samsvarer med en forventet struktur, inkludert datatyper, påkrevde egenskaper, verdibegrensninger og nestede objekter/arrayer. Skjema-validering gjøres vanligvis ved bruk av JSON Schema, som definerer regler for hva som regnes som gyldige data.

Hvorfor validere JSON?

Validering av JSON er avgjørende overalt der data serialiseres for overføring, lagring eller kommunikasjon mellom tjenester. Viktige grunner inkluderer:

• Feilforebygging: Oppdag og rapporter syntaksfeil (f.eks. manglende komma, ubalanserte parenteser, ugyldige tegn) tidlig – før data behandles.
• Dataintegritet og sikkerhet: Avvis ugyldige eller ondsinnede JSON-payloads for å forhindre krasj i backend, injeksjonsangrep eller datakorrupsjon.
• Typsikkerhet: Håndhev streng typetilpasning—sørg for for eksempel at et felt som forventes å være en boolsk verdi ikke sendes som en tekststreng, eller at UUID-er, e-poster og tall følger korrekt format.
• Tverrspråklig kompatibilitet: Sikre at JSON som genereres i ett miljø (f.eks. Node.js) trygt kan brukes i et annet (f.eks. Python, Go, Java), og unngå feil ved serialisering/deserialisering.
• Vedlikeholdbarhet og Robusthet: Validerte datastrukturer forbedrer sporbarheten og reduserer risikoen for vanskelig å feilsøke feil i konfigurasjonsfiler, logger eller API-forespørsler/-svar.
• Personvern og sikkerhet: Validering kan utføres helt på klientsiden (i nettleseren), noe som forhindrer at rådata eller sensitiv informasjon forlater brukerens enhet under valideringen.

Vanlige JSON-valideringsfeil (med detaljerte eksempler)

Nøkler uten anførselstegn

Alle nøkler i JSON-objekter må være dobbeltanførte strenger.

{ navn: "Alice" }

{ "name": "Alice" }

Mange JSON-lignende formater (f.eks. JavaScript-objektlitteraler) tillater nøkler uten anførselstegn, men standard JSON gjør ikke det.

Enkelt anførselstegn

JSON-strenger må bruke doble anførselstegn; enkeltanførselstegn er ikke tillatt.

{ 'navn': 'Bob' }

{ "name": "Bob" }

Bruk av enkeltsitater vil føre til parserfeil i alle JSON-biblioteker som følger standarden.

Etterslepende kommaer

Ingen komma på slutten av det siste elementet i et objekt eller en liste.

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

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

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

Feil ved flukt av tegn

Anførselstegn og spesialtegn i strenger må unngås ved bruk av bakoverstrek (backslash).

{ "quote": "Tom sa \"hei\"" }

{ "quote": "Tom sa \"hei\"" }

Andre escape-sekvenser inkluderer \\ for backslash, \n for nye linjer, og \t for tabulatorer.

Feil datatyper

Strenger bør ikke brukes for tall, boolske verdier eller null.

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

{ "aktivert": true, "antall": 10 }

JSON skiller mellom boolske verdier, tall og strenger – sørg for at riktig type brukes.

Ikke-primitive nøkler

JSON-objektnøkler må alltid være strenger; du kan ikke bruke tall, boolske verdier eller andre typer som nøkler.

{ 123: "abc" }

{ "123": "abc" }

Dupliserte nøkler

Selv om det er tillatt i JSON-spesifikasjonen, er dupliserte nøkler en vanlig årsak til feil.

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

De fleste tolker vil bare beholde den siste verdien ("Bob"), og stille forkaste de tidligere.

Bruk av kommentarer

Standard JSON tillater ikke kommentarer, selv om noen redigeringsprogrammer støtter dem.

{
  // Brukerinformasjon
  "name": "Alice"
}

{
  "name": "Alice"
}

Skjemavalidering: Sikring av struktur og datatyper

JSON Schema er en kraftig standard for å definere og validere forventet struktur i JSON-dokumenter. Den gjør det mulig å spesifisere:

• Påkrevde felt (`required`)
• Datatyper (`type`: streng, tall, boolsk, objekt, matrise, null)
• Strengformater (`format`: e-post, uuid, dato-tid, osv.)
• Mønstersøk for strenger (`pattern`)
• Nummerområder (`minimum`, `maksimum`)
• Validering av array-lengde og elementer (`minItems`, `maxItems`, `items`)
• Nestet validering for objekter og matriser
• Enum-begrensninger (`enum`)

Eksempel: Brukerskjema (Utkast-07)

{
  "type": "objekt",
  "properties": {
    "id":    { "type": "streng", "format": "uuid" },
    "name":  { "type": "streng", "minLength": 1 },
    "email": { "type": "streng", "format": "epost" },
    "is_active": { "type": "boolsk" }
  },
  "required": ["id", "name", "email"],
  "additionalProperties": false
}

Dette sikrer:

• id må være en gyldig UUID-streng.
• navn må være en ikke-tom tekststreng.
• e-post må samsvare med standard e-postformat.
• is_active (valgfritt) må være en boolsk verdi.
• Ingen andre egenskaper enn de som er definert ovenfor er tillatt.

Eksempel fra virkeligheten: Validering av Stripe API-responser

Anta at du mottar JSON-svar fra Stripe API (f.eks. PaymentIntent). Skjema-validering sikrer at du aldri behandler ufullstendige eller feiltypede data.

{
  "type": "objekt",
  "properties": {
    "id":      { "type": "streng", "pattern": "^pi_" },
    "object":  { "type": "streng", "const": "betaling_intent" },
    "amount":  { "type": "heltall", "minimum": 1 },
    "currency":{ "type": "streng", "minLength": 3, "maxLength": 3 },
    "status":  { "type": "streng", "enum": [
      "krever_betalingsmetode",
      "krever_bekreftelse",
      "behandler",
      "vellykket",
      "avbrutt"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• id må starte med "pi_"
• objekt må alltid være "payment_intent"
• beløpet må være et heltall større enn eller lik 1
• valuta må være en tresifret bokstavkode (f.eks. "usd", "eur")
• status må være en av de spesifiserte verdiene

Fordeler

• Tidlig feildeteksjon: Oppdag kritiske API-endringer eller ufullstendige data før de påvirker forretningslogikken din.
• Automatisert testing: Bruk skjemaer i CI/CD-pipelines for å validere ekte og oppdiktede svar.
• Tverrteam-konsistens: Standardiser datakontrakter mellom frontend, backend og tredjeparts-APIer.

Riktig JSON-validering—som dekker både syntaks og skjema—forebygger subtile feil, sikrer beste praksis, og beskytter applikasjonene dine mot feilformatert eller ondsinnet input. Enten det brukes i konfigurasjonsfiler, API-payloads eller meldinger mellom tjenester, er solid validering grunnleggende for moderne programvaresystemer.

Personvern og sikkerhet

All validering og skjema-sjekker utføres lokalt i nettleseren din. Ingen data lastes opp eller loggføres. Din JSON forblir helt privat.

Kodeeksempler for JSON-validering

Se hvordan du validerer JSON i ulike programmeringsspråk ved å bruke innebygde biblioteker eller populære rammeverk. Disse eksemplene viser både syntaksvalidering og skjema-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 verktøyet