JSON vs YAML: Vollständiger Vergleich und Anwendungsfälle

# JSON vs YAML: Vollständiger Vergleich

JSON und YAML sind zwei der beliebtesten Datenformate für Konfiguration und Datenaustausch. Dieser Leitfaden hilft Ihnen, das richtige Format für Ihre Anforderungen zu wählen.

Grundlegende Unterschiede

JSON (JavaScript Object Notation)

{
  "name": "Webserver",
  "version": "1.0.0",
  "settings": {
    "port": 8080,
    "host": "localhost",
    "ssl": true
  },
  "allowedOrigins": [
    "https://example.com",
    "https://api.example.com"
  ]
}

YAML (YAML Ain't Markup Language)

name: Webserver
version: 1.0.0
settings:
  port: 8080
  host: localhost
  ssl: true
allowedOrigins:
  - https://example.com
  - https://api.example.com

Detaillierter Vergleich

Lesbarkeit

JSON:

• Strukturiert mit geschweiften Klammern
• Mehr Syntax-Zeichen
• Kompakter, aber weniger übersichtlich

YAML:

• Einrückungsbasiert (wie Python)
• Minimal an Syntax
• Menschenfreundlicher für längere Texte

Syntax-Beispiel

// JSON: Explizite Syntax
{
  "database": {
    "connections": [
      {
        "name": "primary",
        "host": "db1.example.com",
        "port": 5432
      },
      {
        "name": "replica",
        "host": "db2.example.com",
        "port": 5432
      }
    ]
  }
}

# YAML: Minimale Syntax
database:
  connections:
    - name: primary
      host: db1.example.com
      port: 5432
    - name: replica
      host: db2.example.com
      port: 5432

Features im Vergleich

Kommentare

JSON:

{
  "key": "value"
}

❌ Keine nativen Kommentare (JSONC und JSON5 unterstützen sie)

YAML:

# Dies ist ein Kommentar
key: value  # Inline-Kommentar auch möglich

✅ Vollständige Kommentar-Unterstützung

Mehrzeilige Strings

JSON:

{
  "description": "Dies ist eine\nlange Beschreibung\nmit mehreren Zeilen"
}

YAML:

# Literal Block (behält Zeilenumbrüche)
description: |
  Dies ist eine
  lange Beschreibung
  mit mehreren Zeilen

# Folded Block (faltet zu einer Zeile)
summary: >
  Dies wird zu einer
  einzigen langen Zeile
  zusammengefasst

Anker und Aliase (Wiederverwendung)

JSON:

{
  "defaults": {
    "timeout": 30,
    "retries": 3
  },
  "service1": {
    "timeout": 30,
    "retries": 3,
    "url": "https://api1.example.com"
  },
  "service2": {
    "timeout": 30,
    "retries": 3,
    "url": "https://api2.example.com"
  }
}

❌ Keine Wiederverwendung (manuelle Duplizierung)

YAML:

defaults: &defaults
  timeout: 30
  retries: 3

service1:
  <<: defaults

  url: https://api1.example.com

service2:
  <<: defaults
  url: https://api2.example.com

✅ Anker und Aliase vermeiden Duplikation

Datentypen

JSON:

• String
• Number
• Boolean (true/false)
• null
• Object
• Array

YAML:

Alle JSON-Typen plus:

• Timestamps: 2026-01-26T10:00:00Z
• Integers mit verschiedenen Basen: 0x14 (hex), 0o20 (oktal)
• Infinity: .inf, -.inf
• Not a Number: .nan

# YAML erweiterte Typen
date: 2026-01-26
hex_value: 0xFF
infinity: .inf
not_a_number: .nan

Performance-Vergleich

Parsing-Geschwindigkeit

import json
import yaml
import time

data = {
    "users": [{"name": f"User{i}", "id": i} for i in range(1000)]
}

# JSON Benchmark
json_str = json.dumps(data)
start = time.time()
for _ in range(1000):
    json.loads(json_str)
json_time = time.time() - start

# YAML Benchmark
yaml_str = yaml.dump(data)
start = time.time()
for _ in range(1000):
    yaml.safe_load(yaml_str)
yaml_time = time.time() - start

print(f"JSON: {json_time:.3f}s")
print(f"YAML: {yaml_time:.3f}s")
print(f"JSON ist {yaml_time/json_time:.1f}x schneller")

Typische Ergebnisse:

• JSON ist 5-10x schneller beim Parsing
• JSON hat weniger Overhead
• YAML ist komplexer zu parsen

Dateigröße

# Beispiel-Vergleich
JSON-Datei: 1.2 MB
YAML-Datei: 1.0 MB (ca. 15-20% kleiner)

YAML ist oft etwas kompakter aufgrund minimaler Syntax.

Praktische Anwendungsfälle

Wann JSON verwenden

✅ APIs und Webservices

// REST API Response
fetch('https://api.example.com/users')
  .then(res => res.json())
  .then(data => console.log(data));

✅ Konfigurationsdateien für JavaScript/TypeScript

// package.json, tsconfig.json
{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs"
  }
}

✅ Datenübertragung mit hoher Performance

{
  "type": "metrics",
  "timestamp": 1706265600,
  "values": [100, 200, 300]
}

✅ NoSQL-Datenbanken (MongoDB, CouchDB)

{
  "_id": "507f1f77bcf86cd799439011",
  "name": "Produkt",
  "price": 29.99
}

Wann YAML verwenden

✅ Konfigurationsdateien für DevOps

# Docker Compose
version: '3.8'
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
    environment:
      - NODE_ENV=production

✅ CI/CD Pipelines

# GitHub Actions
name: CI
on: [push, pull_request]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Run tests
        run: npm test

✅ Kubernetes-Manifeste

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
spec:
  containers:
    - name: nginx
      image: nginx:1.21
      ports:
        - containerPort: 80

✅ Umfangreiche Dokumentation

documentation:
  overview: |
    Dies ist eine umfassende Beschreibung
    die mehrere Zeilen umfasst und
    gut lesbar formatiert ist.

  sections:
    - title: Einführung
      content: >
        Langer Text der automatisch
        in eine Zeile umgebrochen wird.

Konvertierung zwischen Formaten

JSON zu YAML

import json
import yaml

# JSON laden
with open('config.json', 'r') as f:
    data = json.load(f)

# Als YAML speichern
with open('config.yaml', 'w') as f:
    yaml.dump(data, f, default_flow_style=False)

const yaml = require('js-yaml');
const fs = require('fs');

// JSON laden
const jsonData = JSON.parse(fs.readFileSync('config.json', 'utf8'));

// Als YAML speichern
const yamlStr = yaml.dump(jsonData);
fs.writeFileSync('config.yaml', yamlStr);

YAML zu JSON

import json
import yaml

# YAML laden
with open('config.yaml', 'r') as f:
    data = yaml.safe_load(f)

# Als JSON speichern
with open('config.json', 'w') as f:
    json.dump(data, f, indent=2)

const yaml = require('js-yaml');
const fs = require('fs');

// YAML laden
const yamlData = yaml.load(fs.readFileSync('config.yaml', 'utf8'));

// Als JSON speichern
fs.writeFileSync('config.json', JSON.stringify(yamlData, null, 2));

Sicherheitsaspekte

JSON-Sicherheit

✅ Sicherer: JSON.parse() ist relativ sicher

const data = JSON.parse(userInput);  // Sicher

⚠️ Vorsicht: eval() niemals verwenden

eval('(' + userInput + ')');  // GEFÄHRLICH!

YAML-Sicherheit

⚠️ Vorsicht: YAML kann Code ausführen

import yaml

# UNSICHER - kann beliebigen Python-Code ausführen
data = yaml.load(user_input)

# SICHER - nur einfache Datentypen
data = yaml.safe_load(user_input)

YAML-Angriff-Beispiel:

!!python/object/apply:os.system
args: ['rm -rf /']

Empfehlung: Immer safe_load() verwenden!

Werkzeuge und Ökosystem

JSON-Tools

• Validatoren: JSONLint, ajv
• Formatter: Prettier, jq
• Schema: JSON Schema
• Query: jq, JSONPath

YAML-Tools

• Validatoren: yamllint, YAML Validator
• Formatter: prettier, yq
• Linter: yamllint
• Query: yq

Schema-Validierung

JSON Schema

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "name": {"type": "string"},
    "age": {"type": "number", "minimum": 0}
  },
  "required": ["name"]
}

YAML Schema (mit JSON Schema)

# Validierung mit JSON Schema möglich
name: Max Mustermann
age: 30

Hybrid-Ansätze

YAML für Entwicklung, JSON für Produktion

// build.js
const yaml = require('js-yaml');
const fs = require('fs');

// Entwicklung: YAML bearbeiten
const config = yaml.load(fs.readFileSync('config.yaml'));

// Produktion: JSON generieren (schneller)
fs.writeFileSync('config.json', JSON.stringify(config));

Entscheidungshilfe

| Kriterium | JSON | YAML |

|-----------|------|------|

| Performance | ✅ Schneller | ⚠️ Langsamer |

| Lesbarkeit | ⚠️ Gut | ✅ Sehr gut |

| Kommentare | ❌ Nein | ✅ Ja |

| Komplexität | ✅ Einfach | ⚠️ Komplex |

| API-Unterstützung | ✅ Standard | ⚠️ Selten |

| Konfiguration | ⚠️ Möglich | ✅ Ideal |

| Datengröße | ⚠️ Größer | ✅ Kleiner |

| Tool-Support | ✅ Exzellent | ✅ Sehr gut |

| Sicherheit | ✅ Sicher | ⚠️ Vorsicht! |

Best Practices

Für JSON

Verwenden Sie Formatter - Prettier, JSON.stringify mit indent

Validieren Sie - JSON Schema verwenden

Minimieren Sie - Für Produktion komprimieren

Versionieren Sie - Git-freundliches Format

Für YAML

Konsistente Einrückung - 2 Spaces empfohlen

safe_load verwenden - Sicherheit first

Kommentare nutzen - Dokumentieren Sie Entscheidungen

Linting aktivieren - yamllint für Konsistenz

Zusammenfassung

Verwenden Sie JSON für:

• REST APIs
• Datenübertragung
• Performance-kritische Anwendungen
• JavaScript/Browser-Umgebungen

Verwenden Sie YAML für:

• Konfigurationsdateien
• DevOps und CI/CD
• Menschenlesbare Dokumente
• Kubernetes und Container-Orchestrierung

Beide Formate haben ihre Stärken - wählen Sie basierend auf Ihrem spezifischen Anwendungsfall!