JSON Schema Validator

Vad är JSON Schema-validering?

JSON Schema-validering är processen att kontrollera om ett JSON-dokument uppfyller en uppsättning strukturella villkor och värdebegränsningar definierade i ett JSON Schema. Schemat i sig är ett JSON-dokument som beskriver den förväntade strukturen hos din data: vilka egenskaper som är obligatoriska, vilka typer de måste ha, tillåtna intervall för tal, strängmönster, arraylängder med mera. JSON Schema-specifikationen underhålls på json-schema.org och publiceras som en serie IETF-utkast; Draft 7 och Draft 2020-12 är de mest använda.

Vanlig JSON-validering kontrollerar bara syntax (är parenteserna matchade? är strängar citerade?), men schemavalidering går längre. Den besvarar frågor som: innehåller svaret från detta API ett fält "id" som alltid är ett heltal? Är fältet "status" ett av tre tillåtna värden? Har nästlade objekt rätt struktur? Den här typen av strukturell verifiering fångar fel som syntaxkontroller missar helt, eftersom syntaktiskt giltig JSON ändå kan vara semantiskt felaktig för din applikation.

JSON Schema används i OpenAPI/Swagger-definitioner, validering av konfigurationsfiler, formulärvalidering, dokumentbegränsningar i databaser och automatiserad testning. Verktyg som Ajv (JavaScript), jsonschema (Python) och check-jsonschema (CLI) implementerar specifikationen så att du kan validera data programmatiskt. Den här online-validatorn låter dig klistra in både ett schema och ett datadokument för att omedelbart kontrollera överensstämmelse — utan att installera något bibliotek.

Varför använda en online JSON Schema-validator?

Att skriva scheman och felsöka valideringsfel för hand är tidskrävande. En online JSON Schema-validator ger dig omedelbar återkoppling på om din data matchar ditt schema, med tydliga felmeddelanden som pekar på exakt vilken egenskap som misslyckades.

Användningsfall för JSON Schema-validering

Referens för JSON Schema-nyckelord

Ett JSON Schema byggs upp av nyckelord som var och ett ställer ett villkor på den validerade datan. Tabellen nedan listar de vanligast använda nyckelorden i Draft 7 och senare. Varje nyckelord kan kombineras med andra i samma schemaobjekt.

Jämförelse av JSON Schema-utkast: Draft 7 vs 2019-09 vs 2020-12

JSON Schema har genomgått flera utkastversioner. Draft 7 (publicerat 2018) har bredast stöd i verktyg. Draft 2019-09 introducerade $defs (ersätter definitions), unevaluatedProperties och $recursiveRef. Draft 2020-12 (den senaste stabila versionen) ersatte $recursiveRef med $dynamicRef och introducerade prefixItems för tuppelvalidering. Kontrollera att ditt valideringsbibliotek stöder det utkast du väljer. Ajv stöder alla tre. Pythons jsonschema-bibliotek stöder upp till 2020-12 sedan version 4.0.

Kodexempel

Dessa exempel visar hur man validerar JSON mot ett schema programmatiskt. Varje exempel använder ett välunderhållet bibliotek för sitt språkekosystem.

import Ajv from 'ajv';

const ajv = new Ajv();

const schema = {
  type: 'object',
  properties: {
    name: { type: 'string', minLength: 1 },
    age: { type: 'integer', minimum: 0 },
    email: { type: 'string', format: 'email' }
  },
  required: ['name', 'email'],
  additionalProperties: false
};

const data = { name: 'Alice', age: 30, email: 'alice@example.com' };

const validate = ajv.compile(schema);
const valid = validate(data);
console.log(valid);          // → true
console.log(validate.errors); // → null

// Invalid data — missing required "email"
validate({ name: 'Bob', age: 25 });
console.log(validate.errors);
// → [{ instancePath: '', keyword: 'required', params: { missingProperty: 'email' } }]

from jsonschema import validate, ValidationError

schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string", "minLength": 1},
        "age": {"type": "integer", "minimum": 0},
        "tags": {
            "type": "array",
            "items": {"type": "string"},
            "uniqueItems": True
        }
    },
    "required": ["name"]
}

# Valid data
validate(instance={"name": "Alice", "age": 30, "tags": ["admin"]}, schema=schema)
# → No exception raised

# Invalid data — wrong type for "age"
try:
    validate(instance={"name": "Alice", "age": "thirty"}, schema=schema)
except ValidationError as e:
    print(e.message)
    # → 'thirty' is not of type 'integer'
    print(e.json_path)
    # → $.age

package main

import (
    "fmt"
    "strings"
    "github.com/santhosh-tekuri/jsonschema/v5"
)

func main() {
    schemaJSON := `{
        "type": "object",
        "properties": {
            "id": { "type": "integer" },
            "status": { "enum": ["active", "inactive"] }
        },
        "required": ["id", "status"]
    }`

    compiler := jsonschema.NewCompiler()
    compiler.AddResource("schema.json", strings.NewReader(schemaJSON))
    schema, _ := compiler.Compile("schema.json")

    // Valid data
    data := map[string]interface{}{"id": 1, "status": "active"}
    err := schema.Validate(data)
    fmt.Println(err) // → <nil>

    // Invalid — missing "status"
    bad := map[string]interface{}{"id": 2}
    err = schema.Validate(bad)
    fmt.Println(err) // → validation failed: missing properties: 'status'
}

# Install via pip
pip install check-jsonschema

# Validate a file against a schema
check-jsonschema --schemafile schema.json data.json
# → ok -- validation done

# Validate against a remote schema (e.g., GitHub Actions workflow)
check-jsonschema --builtin-schema vendor.github-workflows my-workflow.yml

# Validate multiple files at once
check-jsonschema --schemafile schema.json file1.json file2.json file3.json

Vanliga frågor