JSON zu Markdown

Ähnliche Tools

Über JSON zu Markdown und Markdown-Tabellen

Anwendungsfälle

• Tech-Dokumente: API-Antwort-JSON in Markdown-Tabelle zur Anzeige konvertieren
• GitHub README: Konfigurationsdaten, Parameterbeschreibungen, API-Antwort-Beispiele anzeigen
• Datenberichte: Analyseergebnisse in Markdown-Tabelle präsentieren (Export nach Notion / Confluence)
• API-Dokumente (Swagger / Redoc / OpenAPI): Interface-Antwort-Datenstruktur deutlich anzeigen
• VuePress / Docusaurus / Hexo statische Site-Generatoren Dokumentkapitel
• Slack / Discord / Enterprise-IM: strukturierte Daten teilen (GFM nativ unterstützt)
• VS Code / JetBrains IDE Markdown-Vorschau Echtzeit-Tabellen-Effektvorschau
• Versionskontroll-Zusammenarbeit: Markdown-Tabelle ist reiner Text, git diff freundlich, einfaches Code-Review
• Lehre: verschachtelte JSON-Aufgaben der Schüler in Tabellen zur vereinheitlichten Überprüfung konvertieren
• E-Mail-Vorlagen (Markdown-unterstützende E-Mail-Clients wie Bear Mail, HEY)
• Notion-Datenbank-Import: zuerst Markdown-Tabelle generieren, dann in Notion einfügen
• Internationalisierung: JSON-Abflachung + Schlüsselverschönerung, gleiche Struktur in Sprachdokumenten teilen

Anleitung

1. JSON-Array (Empfohlen) oder verschachteltes Objekt in linken Editor einfügen, oder 'Sample' anklicken zum Laden von 3 verschachtelten Benutzer-Beispielen, oder 'Upload' zum Hochladen von .json / .txt
2. Verschachtelungsmodus in Toolbar wählen (Empfohlen 'Flatten'), bei mehrstufiger Verschachtelung Max Depth erhöhen
3. Für benutzerdefiniertes Trennzeichen Separator-Eingabefeld ausfüllen (Standard `.`, kann zu `_` / `-` / `/` geändert werden)
4. Strategy wählen: einzelnes Array 'Single'; Multi-Array-Feld 'Multi' für Auto-Aufteilung; erzwungene Aufteilung 'Split'
5. Stiloptionen umschalten: Sort columns / Beautify keys / Exclude empty / Include Caption / Include Index
6. Ausrichtung wählen: links / zentriert / rechts
7. Auf 'Convert'-Schaltfläche klicken (oder Enter drücken) zum Auslösen der Konvertierung; Eingabe hat 500ms Debounce
8. Rechts wird generierter Markdown-Tabellencode angezeigt, nach Zufriedenheit 'Copy' zum Kopieren in Markdown-Dokument oder 'Download' zum Speichern als table.md

Funktionen

• Automatisches Abflachen verschachtelter Objekte: rekursiv {user:{name,age}} in Punkt-Schlüssel expandieren (Tiefe 1-6) – kein eigenes Flatten-Skript nötig
• 4 Verschachtelungsmodi: Abflachen (Empfohlen, Tiefe einstellbar) / Erster Schlüssel (verschachtelt als einzelne JSON-Spalte) / Stringifizieren (verschachtelt → JSON-String) / Roh-JSON (jede Zeile = ein JSON-Block)
• Smarte Multi-Tabellen-Aufteilung: erkennt Top-Level-Array-Felder (z. B. users, orders), teilt automatisch in mehrere Markdown-Tabellen mit ### Caption auf
• Benutzerdefiniertes Trennzeichen: Flatten-Modus standardmäßig `.` (Lodash / MongoDB-Konvention), anpassbar zu `_` / `-` / `/`
• Schlüsselverschönerung (camelCase / snake_case → Title Case): `user_name` → `User Name`, `userProfileId` → `User Profile Id`
• Spaltensortierung: Ein Klick sortiert alle Header alphabetisch, für stabile Spaltenreihenfolge zwischen Dokumenten
• Leere-Spalten-Ausschluss: erkennt automatisch Spalten, bei denen alle Zeilen null / undefined / leerer String sind, und schließt sie aus
• 3 Ausrichtungsstile: links (`:-`) / zentriert (`:-:`) / rechts (`-:`), nach GFM-Spezifikation
• Zeilenindex-Umschalter: optionale #-Nummerierungsspalte ganz links mit anpassbarem Header-Text
• Caption-Umschalter: generiert automatisch `### Name` H3-Überschrift über jeder Tabelle für klare Dokument-Navigation und SEO
• Typbewusste Escape: `|` / `\` / Zeilenumbruch automatisch escaped zu `\|` / `\\` / `<br>`, keine kaputten Markdown-Tabellen
• Generierungs-Statistik-Feedback: Fußzeile zeigt 'N Tabellen × M Zeilen × K Spalten' + Bytes zum Debuggen großer JSON-Daten
• Beispieldaten + Datei-Upload: 3 integrierte verschachtelte Benutzer-Beispiele, Drag-Drop oder Klick zum Hochladen von .json / .txt
• Vollständig lokal im Browser: alle Operationen Parsen / Abflachen / Markdown-Generierung / Kopieren / Herunterladen im Browser, keine Daten an Server

Codebeispiele

async function fetchUsers() {
  const res = await fetch('https://api.github.com/users?per_page=10');
  return await res.json();
}

function flattenObject(obj, prefix = '', sep = '.', result = {}, depth = 0, maxDepth = 3) {
  if (!obj || typeof obj !== 'object' || Array.isArray(obj)) return result;
  if (depth >= maxDepth) {
    if (prefix) result[prefix] = JSON.stringify(obj);
    return result;
  }
  for (const [k, v] of Object.entries(obj)) {
    const key = prefix ? `${prefix}${sep}${k}` : k;
    if (v && typeof v === 'object' && !Array.isArray(v)) {
      flattenObject(v, key, sep, result, depth + 1, maxDepth);
    } else {
      result[key] = v;
    }
  }
  return result;
}

function generateMarkdownTable(rows, opts = {}) {
  const { align = 'left', includeIndex = false, sortColumns = false } = opts;
  const flat = rows.map(r => flattenObject(r));
  let cols = [...new Set(flat.flatMap(r => Object.keys(r)))];
  if (sortColumns) cols.sort((a, b) => a.localeCompare(b));
  const alignMap = { left: ':-', center: ':-:', right: '-:' };
  const alignSep = alignMap[align];
  const headers = includeIndex ? ['#', ...cols] : cols;
  const seps = includeIndex ? [alignSep, ...cols.map(() => alignSep)] : cols.map(() => alignSep);
  const escapeCell = v =>
    v == null ? '' :
    typeof v === 'object' ? JSON.stringify(v).slice(0, 60) :
    String(v).replace(/\\|/g, '\\|').replace(/\n/g, '<br>');
  const lines = [];
  lines.push('| ' + headers.join(' | ') + ' |');
  lines.push('| ' + seps.join(' | ') + ' |');
  flat.forEach((r, i) => {
    const idxCell = includeIndex ? [i + 1] : [];
    const cells = cols.map(c => escapeCell(r[c]));
    lines.push('| ' + [...idxCell, ...cells].join(' | ') + ' |');
  });
  return lines.join('\n');
}

const users = await fetchUsers();
const md = generateMarkdownTable(users, { align: 'left', sortColumns: true });
console.log('## GitHub Users\n\n' + md);

import json

def flatten(obj, prefix='', sep='.', result=None, depth=0, max_depth=3):
    if result is None:
        result = {}
    if not isinstance(obj, dict) or depth >= max_depth:
        if prefix:
            result[prefix] = json.dumps(obj) if isinstance(obj, (dict, list)) else obj
        return result
    for k, v in obj.items():
        key = f"{prefix}{sep}{k}" if prefix else k
        if isinstance(v, dict):
            flatten(v, key, sep, result, depth + 1, max_depth)
        else:
            result[key] = v
    return result

def json_to_markdown_table(data, align='left', include_index=False,
                            sort_columns=False, caption=None):
    if isinstance(data, dict):
        data = [data]
    if not data:
        return "<!-- No valid objects found -->"
    flat_rows = [flatten(row) for row in data]
    columns = []
    for row in flat_rows:
        for k in row:
            if k not in columns:
                columns.append(k)
    if sort_columns:
        columns.sort()
    align_sep = {'left': ':-', 'center': ':-:', 'right': '-:'}[align]
    headers = (['#'] if include_index else []) + columns
    seps = ([align_sep] if include_index else []) + [align_sep] * len(columns)
    def escape_cell(v):
        if v is None:
            return ''
        if isinstance(v, (dict, list)):
            s = json.dumps(v)
            return s[:60] + '…' if len(s) > 60 else s
        return str(v).replace('|', '\\|').replace('\n', '<br>')
    lines = []
    if caption:
        lines.append(f'### {caption}\n')
    lines.append('| ' + ' | '.join(headers) + ' |')
    lines.append('| ' + ' | '.join(seps) + ' |')
    for i, row in enumerate(flat_rows):
        idx_cell = [str(i + 1)] if include_index else []
        cells = [escape_cell(row.get(c, '')) for c in columns]
        lines.append('| ' + ' | '.join(idx_cell + cells) + ' |')
    return '\n'.join(lines)


if __name__ == '__main__':
    data = json.load(open('weekly_stats.json'))
    md = json_to_markdown_table(data['users'], align='left', sort_columns=True, caption='Wöchentlich aktive Benutzer')
    print(md)

# 1) gh CLI verwenden, um letzte 50 zusammengeführte PRs abzurufen
PR_JSON=$(gh pr list --state merged --limit 50 --json number,title,author,labels,mergedAt)

# 2) Labels verschachteltes Array mit jq abflachen
echo "$PR_JSON" | jq 'map({
  number: .number,
  title: .title,
  author: .author.login,
  labels: (.labels | map(.name) | join(", ")),
  mergedAt: .mergedAt
})' > release_prs.json

# 3) Dieses Tool öffnen, release_prs.json Inhalt einfügen
#    - Toolbar Strategy 'Single' wählen
#    - Sort columns + Include Index aktivieren
#    - Convert klicken
#    - Generierte Markdown-Tabelle kopieren

# 4) In Release Notes einfügen
cat > RELEASE.md <<'EOF'
# v2.1.0 Release Notes

## Was geändert wurde

EOF
sed -i '/## Was/ r /tmp/table.md' RELEASE.md
cat >> RELEASE.md <<'EOF'

Vollständiges Changelog: https://github.com/your/repo/compare/v2.0.0...v2.1.0
EOF

# 5) gh CLI verwenden, um Release zu erstellen
gh release create v2.1.0 -F RELEASE.md -t "v2.1.0"

Häufig gestellte Fragen

Fehlerbehebung

Glossar

Markdown-Tabelle

Aus | und - Zeichen bestehende Klartext-Tabelle, definiert durch GFM- (GitHub Flavored Markdown) Spezifikation. Tool-Ausgabe folgt strikt dieser Syntax, kann direkt von GitHub / GitLab / Notion / Confluence gerendert werden.

GFM

GitHub Flavored Markdown Abkürzung, Dialekt-Erweiterung von GitHub über Standard-Markdown, einschließlich Tabellen, Durchstreichung, Aufgabenlisten, automatischer Verknüpfungen. Vom Tool generierte Tabelle entspricht GFM-Spezifikation.

CommonMark

Markdown-Syntax-Standardisierungsspezifikation (2014 veröffentlicht). GFM-Tabellen-Syntax erweitert über CommonMark. Tool-Ausgabe kann sowohl von strikten CommonMark-Parsern als auch GFM-Parsern korrekt gerendert werden.

JSON-Array

In eckige Klammern [...] eingewickelte Objektsammlung. Tool verwendet jedes Array-Element als Tabellenzeile; leeres Array generiert keine Tabelle (zeigt Hinweis).

JSON-Objekt

In geschweifte Klammern {} eingewickelte Schlüssel-Wert-Paar-Sammlung. Tool verwendet jeden Objektschlüssel als Tabellen-Header, Wert als Zelle; einzelnes Objekt automatisch als Einzelzeilen-Tabelle verpackt.

Abflachen

Rekursives Expandieren verschachtelter Objekte zu Punkt-getrennten flachen Schlüsselnamen, z. B. {user:{name:'A'}} → 'user.name'. Tool unterstützt 1-6 Tiefen-Auto-Abflachung, Trennzeichen konfigurierbar.

Schlüssel verschönern

Transformationsregel, die snake_case oder camelCase Schlüssel in Title Case umwandelt: user_name → User Name, userProfileId → User Profile Id. Eine der Differenzierungsfähigkeiten des Tools.

Multi-Tabellen-Aufteilung

Erkennt JSON-Top-Level-Array-Felder (z. B. users, orders), teilt automatisch in mehrere unabhängige Markdown-Tabellen. Eine der Differenzierungsfähigkeiten des Tools, jede aufgeteilte Tabelle generiert automatisch ### Caption.

Ausrichtungs-Syntax

GFM-Tabellen-Header-Trennzeile unterstützt : Zeichen zur Ausrichtung: :- links, :-: zentriert, -: rechts. Tool bietet 3 Schaltflächen für Ein-Klick-Wechsel.

Index-Spalte

#-Nummerierungsspalte ganz links der Tabelle (ab 1 inkrementierend), Header-Text anpassbar. Tool standardmäßig deaktiviert, bei Aktivierung bequem zum Verweisen auf Zeilennummern in Dokumenten.

Caption

H3-Überschrift (###) in Markdown, Tool fügt dieses Etikett automatisch über jeder generierten Tabelle hinzu (Standard verwendet Top-Level-Array-Feldname oder benutzerdefinierten Text), hilfreich für Dokumentnavigation und SEO.

Spalten sortieren

Schalter zum alphabetischen Anordnen aller Tabellen-Spalten. Bei Aktivierung bleibt Spaltenreihenfolge konsistent beim Vergleich mehrerer Dokumente, Diff-Tools sehen Änderungen klarer.

Leere ausschließen

Automatischer Ausschluss von Spalten, wenn alle Zeilen dieser Spalte null / undefined / leerer String sind. Tool standardmäßig deaktiviert, bei Aktivierung reduziert drastisch Sparse-Daten-Tabellenbreite.

Markdown-Escape

Escape von Sonderzeichen in Markdown-Tabellen (z. B. |, \, Zeilenumbruch) zu sicherer Form (\|, \\, <br>), um Tabellen-Syntax-Bruch zu vermeiden. Tool macht dieses Escape automatisch, wichtige Verbesserung gegenüber Konkurrenten.

localStorage-Verlauf

Vom Browser bereitgestellter lokaler Schlüssel-Wert-Speicher (Kapazität ~5-10MB). Tool verwendet localStorage zum Speichern letzter Eingaben, kann nach Aktualisierung oder versehentlichem Schließen schnell wiederherstellen.

Debounce

Frontend-Leistungsoptimierungstechnik: Hochfrequente Ereignisse (z. B. Eingabe) Callbacks zur einmaligen Ausführung nach letztem Auslöser zusammenführen. Tool setzt 500ms Debounce, vermeidet Verzögerung bei großer Dateianalyse.

4 Verschachtelungsmodi im Vergleich

Toolbar bietet 4 Modi für verschiedene Verschachtelungs-Szenarien, empfohlen basierend auf JSON-Strukturkomplexität zu wählen:

3 Tabellengenerierungs-Strategien im Vergleich

Toolbars Strategy-Dropdown steuert, wie JSON mit mehreren Array-Feldern verarbeitet wird:

Toolbar 14 konfigurierbare Optionen Referenz

Alle 14 Toolbar-konfigurierbaren Optionen und ihre Wirkungen, für schnelle Kombinationsauswahl:

Privacy & Security

Alle Operationen dieses JSON zu Markdown-Tools JSON-Analyse, verschachtelte Abflachung, Markdown-Generierung, Kopieren / Herunterladen erfolgen vollständig lokal in Ihrem Browser via JavaScript. Eingegebene JSON-Daten und generierter Markdown-Code werden nicht auf Server hochgeladen, nicht aufgezeichnet, zwischengespeichert oder in Cloud gespeichert. Sensible API-Antworten / interne Geschäftsfeld-JSON können sicher verwendet werden, beim Schließen der Seite werden alle Daten gelöscht.

Authoritative References

• GitHubGitHub Flavored Markdown Spec - Tabellen
• CommonMarkCommonMark Spec
• MarkdownMarkdown Offizielle Doku (Daring Fireball)
• MDNMDN - JSON.parse / JSON.stringify
• GitHubGitHub Docs - Informationen in Markdown organisieren
• LodashLodash - flatten / flattenDeep
• jqjq Handbuch - Verschachtelte Objektbehandlung