JSON na Markdown

Powiązane Rekomendacje

O konwersji JSON na Markdown i tabelach Markdown

Przypadki użycia

• Tworzenie dokumentacji technicznej — konwersja danych JSON zwróconych przez API na tabele Markdown do wyświetlenia
• GitHub README — wyświetlanie danych konfiguracyjnych, opisów parametrów i przykładów odpowiedzi API
• Raporty danych — prezentacja wyników analizy w tabelach Markdown (eksport do Notion/Confluence po wygenerowaniu)
• Dokumentacja API (Swagger/Redoc/OpenAPI) — czytelne wyświetlanie struktur danych zwracanych przez interfejsy
• Sekcje dokumentacji dla generatorów statycznych stron (VuePress/Docusaurus/Hexo)
• Udostępnianie ustrukturyzowanych danych w Slack/Discord/komunikatorach firmowych (GFM natywnie obsługiwany na tych platformach)
• Podgląd tabel w VS Code/JetBrains IDE Markdown Preview na żywo
• Współpraca w kontroli wersji: tabele Markdown to czysty tekst, przyjazny dla git diff i Code Review
• Edukacja: konwersja zadań studentów z zagnieżdżonym JSON na jednolite tabele do sprawdzania i oceniania
• Szablony e-maili (klienty poczty z obsługą Markdown: Bear Mail, HEY)
• Import do bazy Notion: wygeneruj tabelę Markdown tym narzędziem, a następnie wklej do Notion
• Internacjonalizacja: ta sama struktura dla dokumentów chińskich i angielskich po spłaszczeniu JSON + Beautify keys

Jak Używać

1. Wklej tablicę JSON (zalecane) lub zagnieżdżony obiekt do lewego edytora, lub kliknij «Sample» aby załadować 3 przykładowe zagnieżdżone dane użytkowników, lub kliknij «Upload» aby przesłać plik .json/.txt
2. Wybierz tryb obsługi zagnieżdżeń na pasku narzędzi (zalecany «Flatten»), przy głębokim zagnieżdżeniu zwiększ Max Depth
3. W razie potrzeby niestandardowego separatora wprowadź go w polu Separator (domyślnie `.`, można zmienić na `_` / `-` / `/`)
4. Wybierz Strategy: «Single» dla prostej tablicy, «Multi» dla automatycznego dzielenia wielu tablic, «Split» dla wymuszonego dzielenia
5. Zaznacz opcje stylu: Sort columns, Beautify keys, Exclude empty, Include Caption, Include Index
6. Wybierz wyrównanie: do lewej / do środka / do prawej
7. Kliknij «Convert» (lub naciśnij Enter) aby uruchomić konwersję — ochrona przed drganiem 500 ms przy wprowadzaniu
8. Sprawdź wygenerowany kod tabeli Markdown po prawej stronie, następnie kliknij «Copy» aby skopiować kod i wkleić do dokumentu Markdown, lub «Download» aby zapisać jako plik table.md

Funkcje

• Automatyczne spłaszczanie zagnieżdżonych obiektów: rekurencyjne rozwijanie `{user:{name,age}}` do `user.name`, `user.age` z notacją kropkową (głębokość 1-6), bez ręcznego pisania skryptów
• 4 tryby obsługi zagnieżdżeń: Flatten (zalecany, regulowana głębokość) / First Key (zagnieżdżone obiekty jako pojedyncza kolumna JSON) / Stringify (zagnieżdżone obiekty jako łańcuch JSON) / Raw JSON (każdy wiersz jako pełny blok JSON)
• Inteligentny podział na wiele tabel: rozpoznawanie tablic najwyższego poziomu (`users`, `orders`), automatyczne dzielenie na niezależne tabele Markdown z nagłówkami ###, idealne dla złożonych danych biznesowych
• Niestandardowy separator: domyślnie `.` (zgodny z Lodash/MongoDB), można zmienić na `_` / `-` / `/` w pasku narzędzi
• Upiększanie kluczy (camelCase/snake_case → Title Case): `user_name` → `User Name`, `userProfileId` → `User Profile Id` — nagłówki stają się czytelne dla człowieka
• Sortowanie kolumn: sortowanie wszystkich nagłówków alfabetycznie jednym kliknięciem dla stabilnej kolejności przy porównywaniu dokumentów
• Wykluczanie pustych kolumn: automatyczne wykrywanie i wykluczanie kolumn, gdzie wszystkie wiersze to null/undefined/pusty ciąg
• 3 tryby wyrównywania: do lewej (`:-`) / do środka (`:-:`) / do prawej (`-:`) zgodnie ze specyfikacją GFM
• Kolumna indeksu wierszy: opcjonalna kolumna `#` po lewej stronie (konfigurowalny nagłówek), ułatwia odwoływanie się do numerów wierszy
• Nagłówek Caption: automatyczne generowanie `### NazwaDanych` (H3) nad każdą tabelą, struktura dokumentu staje się przejrzysta, pomaga w SEO
• Eskalowanie świadome typów: `|` / `\` / znaki nowej linii w komórkach automatycznie eskalowane do `\|` / `\\` / `<br>`, zapobiega uszkodzeniu składni tabeli Markdown
• Statystyki generowania: pasek statusu na dole pokazuje „Wygenerowano N tabel × M wierszy × K kolumn” + rozmiar w bajtach na żywo, przy debugowaniu długich JSON-ów skala danych widoczna na pierwszy rzut oka
• Przykładowe dane + przesyłanie plików: 3 wbudowane przykłady użytkowników zagnieżdżonych, przeciągnij i upuść lub kliknij, aby przesłać plik .json/.txt
• W pełni lokalne przetwarzanie: całe parsowanie JSON, spłaszczanie, generowanie Markdown i operacje kopiowania/pobierania odbywają się w przeglądarce, dane nie są wysyłane na serwer

Przykłady kodu

// 1) Wywołanie GitHub API, aby uzyskać listę użytkowników
async function fetchUsers() {
  const res = await fetch('https://api.github.com/users?per_page=10');
  return await res.json();
}

// 2) Funkcja spłaszczania zagnieżdżeń (odpowiednik logiki Flatten tego narzędzia)
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;
}

// 3) Konwersja spłaszczonych danych na tabelę Markdown
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');
}

// 4) Wyjście do README.md
const users = await fetchUsers();
const md = generateMarkdownTable(... [truncated]

from flask import Flask, jsonify
import json

app = Flask(__name__)

def flatten(obj, prefix='', sep='.', result=None, depth=0, max_depth=3):
    """Rekurencyjne spłaszczanie zagnieżdżonych obiektów"""
    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.appe... [truncated]

# 1) Pobierz ostatnie 50 scalonych PR przez gh CLI
PR_JSON=$(gh pr list --state merged --limit 50 --json number,title,author,labels,mergedAt)

# 2) Spłaszczanie zagnieżdżonej tablicy labels przez jq
echo "$PR_JSON" | jq 'map({
  number: .number,
  title: .title,
  author: .author.login,
  labels: (.labels | map(.name) | join(", ")),
  mergedAt: .mergedAt
})' > release_prs.json

# 3) Otwórz to narzędzie, wklej zawartość, Strategy: "Single",
#    zaznacz Sort columns + Include Index, kliknij Convert, skopiuj tabelę

# 4) Wstaw do Release Notes i utwórz Release
gh release create v2.1.0 -F RELEASE.md -t "v2.1.0"

Często Zadawane Pytania

Rozwiązywanie problemów

Słownik

Tabela Markdown

Czysto tekstowa tabela zbudowana ze znaków | i -, zdefiniowana przez specyfikację GFM (GitHub Flavored Markdown). Kod generowany przez to narzędzie ściśle odpowiada tej składni i może być bezpośrednio renderowany w GitHub/GitLab/Notion/Confluence.

GFM

Skrót od GitHub Flavored Markdown — dialekt rozszerzony przez GitHub na standardowym Markdown, obejmujący tabele, przekreślenia, listy zadań, automatyczne linki itp. Tabele generowane przez to narzędzie są zgodne ze specyfikacją GFM.

CommonMark

Znormalizowana specyfikacja składni Markdown (ogłoszona w 2014). Składnia tabel GFM jest rozszerzeniem CommonMark. Wynik tego narzędzia może być poprawnie renderowany zarówno przez ścisłe parsery CommonMark, jak i parsery GFM.

Tablica JSON

Kolekcja obiektów w nawiasach kwadratowych [...]. To narzędzie traktuje każdy obiekt w tablicy jako jeden wiersz tabeli. Pusta tablica nie generuje tabeli (wyświetla podpowiedź).

Obiekt JSON

Kolekcja par klucz-wartość w nawiasach klamrowych {}. To narzędzie traktuje każdy klucz obiektu jako nagłówek, a wartość jako komórkę. Pojedynczy obiekt jest automatycznie opakowywany w jednowierszową tabelę.

Spłaszczanie zagnieżdżeń (Flatten)

Rekurencyjne rozwijanie zagnieżdżonych obiektów do płaskich nazw kluczy rozdzielonych kropką. Przykład: {user:{name:'A'}} → 'user.name'. To narzędzie obsługuje automatyczne spłaszczanie na głębokość 1-6 poziomów z konfigurowalnym separatorem.

Upiększanie kluczy (Beautify Keys)

Reguła przekształcania kluczy snake_case lub camelCase na Title Case: user_name → User Name, userProfileId → User Profile Id. Jedna z wyróżniających możliwości tego narzędzia.

Inteligentny podział na wiele tabel (Multi-Table Split)

Rozpoznawanie pól tablicowych najwyższego poziomu JSON (users, orders itp.) i automatyczne dzielenie na wiele niezależnych tabel Markdown. Jedna z wyróżniających możliwości tego narzędzia — każda podzielona tabela automatycznie otrzymuje nagłówek ###.

Składnia wyrównania (Alignment)

Wiersz separatora nagłówka tabeli GFM obsługuje kontrolę wyrównania przez znak :: :- wyrównanie do lewej, :-: do środka, -: do prawej. To narzędzie udostępnia trzy przyciski do przełączania jednym kliknięciem.

Kolumna indeksu wierszy (Index Column)

Kolumna numeracji # dodawana po lewej stronie tabeli (zaczynając od 1), tekst nagłówka konfigurowalny. To narzędzie domyślnie wyłączone, po włączeniu ułatwia odwoływanie się do numerów wierszy w dokumentach.

Caption

Nagłówek H3 trzeciego poziomu (###) w Markdown. To narzędzie automatycznie dodaje tę etykietę nad każdą wygenerowaną tabelą (domyślnie używając nazwy pola tablicy najwyższego poziomu lub niestandardowego tekstu użytkownika). Pomocne zarówno w nawigacji po dokumencie, jak i SEO.

Sortowanie kolumn (Sort Columns)

Przełącznik sortujący wszystkie kolumny tabeli alfabetycznie. Po włączeniu kolejność kolumn jest stabilna i spójna przy porównywaniu wielu dokumentów, a zmiany widoczne w narzędziach diff są łatwiejsze do zidentyfikowania.

Wykluczanie pustych kolumn (Exclude Empty)

Automatyczne wykluczanie kolumn, gdzie wszystkie wiersze mają wartość null/undefined/pusty ciąg. Domyślnie wyłączone; po włączeniu znacząco zmniejsza szerokość tabel z danymi rzadkimi.

Eskalowanie Markdown (Escape)

Przekształcanie znaków o specjalnym znaczeniu w tabelach Markdown (|, \, znak nowej linii) na bezpieczną formę (\|, \\, <br>) aby zapobiec uszkodzeniu składni tabeli. To narzędzie wykonuje to eskalowanie automatycznie — kluczowa przewaga nad konkurencją.

Historia lokalna (localStorage)

Lokalny magazyn klucz-wartość przeglądarki (pojemność około 5-10MB). To narzędzie używa localStorage do trwałego przechowywania ostatnich danych wejściowych, umożliwiając szybkie odzyskanie po odświeżeniu lub przypadkowym zamknięciu strony.

Ochrona przed drganiem (Debounce)

Technika optymalizacji wydajności frontendu: łączenie wywołań zwrotnych zdarzeń o wysokiej częstotliwości (takich jak wprowadzanie) w jedno wykonanie po ostatnim wyzwoleniu. To narzędzie ustawia 500 ms ochrony przed drganiem, aby zapobiec opóźnieniom podczas parsowania dużych plików.

Porównanie 4 trybów obsługi zagnieżdżonych obiektów

Pasek narzędzi oferuje 4 tryby dla różnych scenariuszy zagnieżdżeń. Zaleca się wybór na podstawie złożoności struktury JSON:

Porównanie 3 strategii generowania tabel

Lista rozwijana Strategy na pasku narzędzi kontroluje sposób obsługi JSON z wieloma polami tablicowymi:

14 konfigurowalnych opcji paska narzędzi — ściągawka

Wszystkie 14 konfigurowalnych opcji paska narzędzi i ich efekty dla szybkiego wyboru kombinacji:

Reguły eskalowania komórek Markdown — ściągawka

Narzędzie automatycznie eskaluje znaki specjalne w komórkach, które mogłyby uszkodzić znaczenie tabeli:

Privacy & Security

Wszystkie operacje parsowania JSON, spłaszczania zagnieżdżeń, generowania Markdown, kopiowania i pobierania w tym narzędziu są wykonywane całkowicie lokalnie w przeglądarce przez JavaScript. Wprowadzone dane JSON i wygenerowany kod Markdown nie są przesyłane na żaden serwer, nie są rejestrowane, buforowane ani przechowywane w chmurze. Poufne JSON-y zawierające niepublikowane odpowiedzi API i wewnętrzne pola biznesowe mogą być bezpiecznie używane — zamknięcie strony usuwa wszystkie dane.

Authoritative References

• GitHubSpecyfikacja GitHub Flavored Markdown — Tabele
• CommonMarkSpecyfikacja CommonMark
• MarkdownOficjalna dokumentacja Markdown (Daring Fireball)
• MDNMDN — JSON.parse / JSON.stringify
• GitHubDokumentacja GitHub — Organizacja informacji w Markdown
• LodashLodash — flatten / flattenDeep
• jqPodręcznik jq — obsługa zagnieżdżonych obiektów