JSON-validator

Vad är JSON-validering?

JSON (JavaScript Object Notation) är ett allmänt använt, lättviktigt format för datautbyte, designat för att vara både lättläst för människor och enkelt för datorer att tolka och generera. Dess huvudsakliga syfte är att representera strukturerad data—objekt, arrayer, strängar, siffror, booleska värden och nullvärden—på ett språkoberoende sätt.

JSON-validering är processen att programmässigt verifiera att ett JSON-dokument är både syntaktiskt och strukturellt korrekt. Detta innebär att två huvudaspekter kontrolleras:

• Syntaxkontroll: Att säkerställa att råtexten följer den formella grammatiken enligt ECMA-404 JSON-specifikationen. Parsers i de flesta moderna programmeringsspråk (t.ex. JSON.parse() i JavaScript, json.loads() i Python, JSONDecoder i Java) förväntar sig giltig syntax och genererar fel om input är felaktigt formaterad.
• Strukturell (Schema) Validering: Utöver syntaxkontroll säkerställer schema validering att JSON-data överensstämmer med en förväntad struktur, inklusive datatyper, obligatoriska egenskaper, värdebegränsningar och nästlade objekt/arrayer. Schema validering utförs vanligtvis med hjälp av JSON Schema, som definierar regler för vad som betraktas som giltig data.

Varför validera JSON?

JSON-validering är avgörande när data serialiseras för överföring, lagring eller kommunikation mellan tjänster. Viktiga skäl inkluderar:

• Felpreventation: Upptäck och rapportera syntaxfel (t.ex. saknade kommatecken, obalanserade parenteser, otillåtna tecken) tidigt – innan data behandlas.
• Dataintegritet och säkerhet: Avvisa felaktiga eller skadliga JSON-paket för att förebygga krascher i backend, injektionsattacker eller datakorruption.
• Typsäkerhet: Säkerställ strikt typkontroll—så att till exempel ett fält som förväntas vara en boolean inte skickas som en sträng, och att UUID, e-postadresser eller nummer följer korrekt format.
• Språkoberoende kompatibilitet: Säkerställ att JSON som genereras i en miljö (t.ex. Node.js) kan användas problemfritt i en annan (t.ex. Python, Go, Java), och undvik fel vid serialisering och deserialisering.
• Underhållbarhet och Robusthet: Validerade datastrukturer förbättrar spårbarheten och minskar risken för svårupptäckta fel i konfigurationsfiler, loggar eller API-förfrågningar/-svar.
• Sekretess och säkerhet: Validering kan utföras helt på klientsidan (i webbläsaren), vilket förhindrar att rådata eller känslig information lämnar användarens enhet för validering.

Vanliga JSON-valideringsfel (med detaljerade exempel)

Oanvända citattecken för nycklar

Alla nycklar i JSON-objekt måste vara strängar inom dubbla citattecken.

{ name: "Alice" }

{ "name": "Alice" }

Många JSON-liknande format (t.ex. JavaScript-objektliteraler) tillåter nycklar utan citationstecken, men standard-JSON kräver alltid citattecken.

Enkelcitat

JSON-strängar måste använda dubbla citattecken; enkla citattecken är inte tillåtna.

{ 'name': 'Bob' }

{ "name": "Bob" }

Att använda enkla citationstecken leder till parserfel i alla JSON-bibliotek som följer standarden.

Släpande kommatecken

Ingen avslutande komma efter det sista objektet i en objekt- eller arraylista.

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

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

Efterföljande kommatecken kan fungera i JavaScript, men inte i strikta JSON-tolkare.

Felaktig escapning av tecken

Citattecken och specialtecken inuti strängar måste undantas med en bakåtsnedstreck.

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

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

Andra escape-sekvenser inkluderar \\ för snedstreck bakåt, \n för nya rader och \t för tabbar.

Felaktiga datatyper

Strängar bör inte användas för siffror, booleska värden eller null.

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

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

JSON skiljer mellan booleska värden, siffror och strängar – se till att rätt typ används.

Icke-primitiva nycklar

JSON-objektnycklar måste alltid vara strängar; du kan inte använda siffror, booleska värden eller andra typer som nycklar.

{ 123: "abc" }

{ "123": "abc" }

Dubbletter av nycklar

Även om det är tillåtet enligt JSON-specifikationen, är dubblettnycklar en vanlig källa till buggar.

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

De flesta parser kommer endast att behålla det sista värdet ("Bob") och tyst ignorera de tidigare.

Användning av kommentarer

Standard JSON tillåter inte kommentarer, även om vissa redigerare stöder dem.

{
  // Användarinformation
  "name": "Alice"
}

{
  "name": "Alice"
}

Schemasvalidering: Säkerställ struktur och datatyper

JSON Schema är en kraftfull standard för att definiera och validera den förväntade strukturen för JSON-dokument. Det låter dig specificera:

• Obligatoriska fält (`required`)
• Datatyper (`typ`: sträng, nummer, boolean, objekt, array, null)
• Strängformat (`format`: e-post, uuid, datum-tid, osv.)
• Mönstermatchning för strängar (`pattern`)
• Nummerintervall (`minimum`, `maximum`)
• Validering av array-längd och element (`minItems`, `maxItems`, `items`)
• Nästa validering för objekt och arrayer
• Enum-begränsningar (`enum`)

Exempel: Användarschema (Utkast-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
}

Vad detta innebär:

• id måste vara en giltig UUID-sträng.
• namnet måste vara en icke-tom sträng.
• e-post måste följa standardformatet för e-postadresser.
• is_active (valfritt) måste vara en boolesk värde.
• Inga andra egenskaper än de som anges ovan är tillåtna.

Verkligt Exempel: Validering av Stripe API-svar

Anta att du mottar JSON-svar från Stripe API (t.ex. PaymentIntent). Schemakontroll kan säkerställa att du aldrig bearbetar ofullständig eller felaktigt typad data.

{
  "type": "objekt",
  "properties": {
    "id":      { "type": "sträng", "pattern": "^pi_" },
    "object":  { "type": "sträng", "const": "betalningsavsikt" },
    "amount":  { "type": "heltal", "minimum": 1 },
    "currency":{ "type": "sträng", "minLength": 3, "maxLength": 3 },
    "status":  { "type": "sträng", "enum": [
      "kräver_betalningsmetod",
      "kräver_bekräftelse",
      "bearbetas",
      "lyckades",
      "avbruten"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• id måste börja med "pi_"
• objekt måste alltid vara "payment_intent"
• belopp måste vara ett heltal större än eller lika med 1
• valuta måste vara en tresiffrig sträng (t.ex. "usd", "eur")
• status måste vara ett av de angivna värdena

Fördelar

• Tidigt felupptäckt: Identifiera kritiska API-ändringar eller ofullständig data innan de påverkar din affärslogik.
• Automatiserad testning: Använd scheman i CI/CD-pipelines för att validera verkliga och simulerade svar.
• Tvärfunktionell konsekvens: Standardisera datakontrakt mellan frontend, backend och tredjeparts-API:er.

Korrekt JSON-validering—som täcker både syntax och schema—förhindrar subtila fel, främjar bästa praxis och skyddar dina applikationer mot felaktig eller skadlig indata. Oavsett om det används i konfigurationsfiler, API-payloads eller tjänsteövergripande meddelanden, är robust validering en grundpelare för moderna mjukvarusystem.

Sekretess & Säkerhet

All validering och schemakontroller sker lokalt i din webbläsare. Ingen data laddas upp eller loggas. Din JSON förblir helt privat.

Kodexempel för JSON-validering

Se hur du validerar JSON i olika programmeringsspråk med inbyggda bibliotek eller populära ramverk. Dessa exempel visar både syntaxvalidering och schemavalidering.

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 detta verktyg