Skip to content

JSON Diff (Porównaj)

Porównaj dwa pliki JSON natychmiast w przeglądarce. Podświetlanie obok siebie, wynik JSON Patch (RFC 6902), ignorowanie szumliwych pól jak znaczniki czasu i identyfikatory. 100% prywatności, bez przesyłania.

Bez śledzenia Działa w przeglądarce Bezpłatne
Ignoruj ścieżki:
Opcje zaawansowane
Tryb tablicy
Reviewed for RFC 6902/6901 compliance and edge cases including null vs missing keys, type drift, floating-point precision, and array key alignment. — Go Tools API Tooling Team · May 4, 2026

Czym jest JSON Diff?

JSON Diff to strukturalne porównanie dwóch dokumentów JSON, które respektuje model danych JSON — klucze są nieuporządkowane, typy są ścisłe, a tablice mogą być uporządkowane lub kluczowane. W przeciwieństwie do diffs tekstowych (które porównują linie i raportują zmianę kolejności kluczy lub białych znaków jako różnice), JSON diff zwraca wyniki semantycznie znaczące.

Kanoniczną, czytelną dla maszyn formą jest JSON Patch (RFC 6902), uporządkowana tablica operacji (add, remove, replace, move, copy, test), która przekształca jeden dokument w drugi. Ścieżki używają JSON Pointer (RFC 6901). Ściśle powiązany: JSON Merge Patch (RFC 7396) — prostszy, ale nie może odróżnić 'usuń klucz' od 'ustaw klucz na null'. To narzędzie zwraca RFC 6902.

Głęboka równość JSON w JavaScript jest trudniejsza niż wygląda. JSON.stringify(a) === JSON.stringify(b) zawodzi przy zmianie kolejności kluczy, wprowadza w błąd przy -0 vs 0 (oba stringifikują do "0"). Poprawny diff musi przejść oba drzewa równolegle używając sumy zbiorów kluczy, odróżnić null od braku klucza przez operator 'in' i zdecydować, co oznacza 'równy' dla liczb (Object.is domyślnie, epsilon dla tolerancji).

To narzędzie działa w całości w Twojej przeglądarce. Dane wejściowe nigdy nie opuszczają Twojej maszyny. Bezpieczne dla odpowiedzi API, wewnętrznych schematów i własnościowych konfiguracji.

Pracujesz z powiązanymi narzędziami JSON? Formatuj za pomocą Formatera JSON; konwertuj za pomocą JSON na YAML i YAML na JSON.

// Two JSON documents that look different but are semantically equal
const a = '{"a":1,"b":2}';
const b = '{"b":2,"a":1}';

// Naive comparison — wrong
JSON.stringify(JSON.parse(a)) === JSON.stringify(JSON.parse(b));
// → false (key order differs)

// JSON Diff (this tool) — correct: key order is irrelevant
// → 0 differences

// JSON Patch (RFC 6902) for { "a": 1 } → { "a": 2 }
// [{ "op": "replace", "path": "/a", "value": 2 }]

Główne funkcje

Widok obok siebie + JSON Patch

Dwa widoki z jednego diffu: wizualne podświetlenie do przeglądu i patch RFC 6902 do automatyzacji.

Ignorowanie szumliwych pól

Presety jednym kliknięciem usuwają /createdAt, /updatedAt, /*Id, /*At, requestId, traceId. Obsługiwane są własne rozszerzone wzorce JSON Pointer.

Dopasowanie tablic po kluczu

Porównaj tablice obiektów po polu id zamiast po indeksie — dla środowisk K8s, wpisów package-lock lub dowolnej logicznie nieuporządkowanej listy.

Domyślna ścisłość typów

1 ≠ "1". null ≠ brak klucza. Wychwytuj dryf serializacji backendu w momencie, gdy pojawia się w testowym wzorcu.

100% w przeglądarce

Dane wejściowe nigdy nie opuszczają Twojej maszyny. Brak przesyłania, brak localStorage dla JSON, brak analityki tego, co wklejasz.

Udostępnij konfigurację, nie dane

Share Link zapisuje tylko konfigurację w URL. Twoje dane wejściowe JSON pozostają lokalne.

Przykłady

Regresja odpowiedzi API

{"user":{"id":1,"name":"Ada","createdAt":"2024-01-01"}}
{"user":{"id":1,"name":"Ada Lovelace","createdAt":"2024-02-02"}}

Dwie zmiany (name + createdAt). Dodaj /user/createdAt do ścieżek ignorowanych — pozostanie tylko zmiana nazwy.

Audyt pliku konfiguracyjnego (zmiana kolejności kluczy)

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

Te same dane, różna kolejność kluczy. JSON Diff traktuje kolejność kluczy jako semantycznie nieistotną — diff jest pusty.

Tablica obiektów (dopasowanie po kluczu)

[{"id":1,"qty":3},{"id":2,"qty":5}]
[{"id":2,"qty":5},{"id":1,"qty":4}]

Przełącz tryb tablicy na 'Dopasuj po kluczu' z key=id. Bez wyrównania każdy element wygląda na zmieniony; z wyrównaniem zmienia się tylko qty dla id=1.

Wyjście JSON Patch (RFC 6902)

{"items":[{"id":1,"price":29.99}]}
{"items":[{"id":1,"price":24.99}]}

Przełącz na kartę JSON Patch, aby uzyskać [{"op":"replace","path":"/items/0/price","value":24.99}], który możesz zastosować za pomocą fast-json-patch.

Jak używać

  1. 1

    Wklej oba dokumenty JSON

    Wklej oryginalny (lewy) i zmodyfikowany (prawy) JSON. Diff renderuje się na żywo podczas pisania; duże dane wejściowe (>200 KB) przełączają się na ręczny przycisk Diff.

  2. 2

    Odfiltruj szum

    Kliknij preset (Timestamps / IDs / Trace) lub wklej rozszerzone wzorce JSON Pointer do pola Ignoruj ścieżki, aby pominąć nieistotne pola.

  3. 3

    Wybierz potrzebny widok

    Widok obok siebie do przeglądu przez człowieka, JSON Patch (RFC 6902) do operacji stosowalnych maszynowo. Użyj Share Link, aby wysłać konfigurację do kolegi.

Typowe pułapki diff

Szum kolejności kluczy (objaw diffs tekstowych)

Jeśli Twoje narzędzie diff raportuje {"a":1,"b":2} vs {"b":2,"a":1} jako różne, wykonuje diff liniowy, nie JSON diff. Klucze JSON są nieuporządkowane — to narzędzie automatycznie ignoruje kolejność kluczy.

✗ Niepoprawne
diff a.json b.json   # text diff: 'everything changed'
✓ Poprawne
JSON Diff (this tool): 0 differences

Mylenie null z brakiem klucza

{"a":null} i {} nie są tym samym. Traktowanie ich jako równych maskuje prawdziwe błędy backendu.

✗ Niepoprawne
{"a": null} == {}   # collapsed by some tools
✓ Poprawne
{"a": null} ≠ {}     # type-strict diff

Kolejność tablicy bez wyrównania po kluczu

[{id:1},{id:2}] vs [{id:2},{id:1}] to nie 'dwie zmiany' dla logicznego zbioru. Sekwencyjny tryb tak to raportuje; przełącz na Dopasuj po kluczu.

✗ Niepoprawne
Sequential diff: 4 modified
✓ Poprawne
Match by key (id): 0 differences

Dryf typów (liczba vs ciąg)

Backendy czasem serializują ID niekonsekwentnie — 42 vs "42". Narzędzie oznacza je jako modyfikacje 'type', abyś mógł wcześnie wychwycić dryf.

✗ Niepoprawne
{"id": 42} vs {"id": "42"}   # serialization bug
✓ Poprawne
Diff reports 'modified (type)' with both values

Precyzja zmiennoprzecinkowa

0.1 + 0.2 !== 0.3 w IEEE 754. Przy tolerancji=0 (domyślnie) jest to oznaczane. Ustaw tolerancję na 1e-9, jeśli zamierzasz równoważność numeryczną.

✗ Niepoprawne
tolerance=0:  0.30000000000000004 ≠ 0.3
✓ Poprawne
tolerance=1e-9: equal

Szum znaczników czasu i UUID

createdAt, updatedAt, requestId, traceId zmieniają się przy każdym żądaniu. Użyj presetów ścieżek ignorowanych, aby je usunąć.

✗ Niepoprawne
Diff: 47 modifications (45 are timestamps)
✓ Poprawne
Add /createdAt, /updatedAt, /requestId to Ignore paths → 2 real changes

Typowe przypadki użycia

Regresja odpowiedzi API
Porównaj odpowiedzi staging vs produkcja; ignoruj znaczniki czasu i ID żądań, aby ujawnić tylko istotne zmiany ładunku.
Awarie testów migawkowych w CI
Wklej rzeczywiste i oczekiwane dane z nieudanego snapshotu Jest/Vitest. Odfiltruj szum i znajdź prawdziwą zmianę w kilka sekund.
Konflikty package-lock / yarn.lock
Rozwiązuj konflikty scalania przez wyrównanie zależności po nazwie; kolejność kluczy i niepowiązane pola przestają być szumem.
Audyt wartości K8s / Helm
Dopasuj envs, volumeMounts i porty po nazwie. Wychwytuj niezamierzone zmiany kolejności vs rzeczywiste edycje konfiguracji.
Pokrycie tłumaczeń i18n
Porównaj strukturalnie en.json z zh.json, aby znaleźć brakujące lub nadmiarowe klucze tłumaczeń bez szumu wartości.
Przegląd planów Terraform / CDK
Porównaj wyjście planów między uruchomieniami; tolerancja numeryczna obsługuje arytmetykę zmiennoprzecinkową, ścieżki ignorowane usuwają ARN i znaczniki czasu.

Szczegóły techniczne

Zgodny z RFC 6902 wynik patch
Generuje prawidłowe operacje JSON Patch (add/remove/replace) ze ścieżkami RFC 6901. Zweryfikowany względem fast-json-patch@3.x i pakietu npm rfc6902.
Iteracyjne przechodzenie drzewa
Przechodzenie ze stosu jawnego (bez rekurencji) ograniczone do 100 000 węzłów i głębokości 64, aby zapobiec przepełnieniu stosu na złośliwych danych wejściowych.
Równość numeryczna Object.is
Domyślna tolerancja numeryczna to 0 — używa Object.is, więc -0 i +0 są rozróżniane. Ustaw tolerancję > 0 dla równości opartej na epsilon.

Najlepsze praktyki

Filtruj przed przeglądaniem
Najpierw dodaj ścieżki ignorowane (znaczniki czasu, ID, pola trace), a następnie czytaj diff. Przeglądanie szumliwych diffów uczy oko, aby pomijało — i przez to przegapiało — prawdziwe zmiany.
Dopasuj po kluczu dla logicznych zbiorów
Jeśli Twoja tablica reprezentuje nieuporządkowany zbiór (envs, użytkownicy, zależności), użyj Dopasowania po kluczu. Sekwencyjny diff na logicznych zbiorach jest prawie zawsze błędny.
Udostępniaj konfigurację, nie dane wejściowe
Użyj Share Link, aby wysłać koledze konfigurację filtrów — nigdy nie wklejaj wrażliwego JSON do współdzielonych dokumentów. URL zawiera tylko konfigurację.

Często zadawane pytania

Dlaczego diff pokazuje, że wszystko się zmieniło, choć zmieniłem tylko jedno pole?
Trzy typowe przyczyny: (1) różna kolejność kluczy — JSON Diff traktuje kolejność kluczy jako równoważną, ale narzędzia do diffs tekstowych nie; (2) znaczniki czasu/UUID/auto-ID zmieniające się przy każdym żądaniu — dodaj je do ścieżek ignorowanych; (3) kolejność tablic, gdy porównanie po indeksie nie powinno mieć zastosowania — przełącz tryb tablicy na 'Dopasuj po kluczu'.
Jak ignorować znaczniki czasu i identyfikatory w JSON diff?
Użyj pola wejściowego Ignoruj ścieżki powyżej. Kliknij preset 'Timestamps' lub 'IDs', aby jednym kliknięciem odfiltrować /createdAt, /updatedAt, /*Id, /*At, /requestId. Możesz też wkleić własne rozszerzone wzorce JSON Pointer — jeden na linię — do zaawansowanego filtrowania.
Jaka jest różnica między JSON Patch a wizualnym diffem?
Wizualny diff (obok siebie) jest dla ludzi — przeglądanie zmian wzrokiem. JSON Patch (RFC 6902) jest dla maszyn — ustrukturyzowana tablica operacji (add/remove/replace), którą możesz zastosować za pomocą pakietów npm fast-json-patch lub rfc6902. Ten sam diff, dwa wyjścia.
Czy JSON diff traktuje null i brakujące klucze tak samo?
Nie. {"a":null} i {} są różne — pierwsze ma jawny null, drugie nie ma klucza. Prawdziwe systemy zachowują się inaczej w obu przypadkach; narzędzie zachowuje je jako odrębne.
Jak porównywane są tablice — po indeksie czy po kluczu?
Domyślnie po indeksie (sekwencyjnie). Przełącz na 'Dopasuj po kluczu' i podaj pole klucza (zazwyczaj id), aby wyrównać elementy niezależnie od kolejności. Używaj do środowisk K8s, wpisów package-lock lub dowolnej listy będącej logicznie zbiorem.
Czy mogę wyeksportować diff jako JSON Patch (RFC 6902)?
Tak. Karta JSON Patch zwraca prawidłową tablicę operacji RFC 6902. Jeśli ustawione są ścieżki ignorowane, patch jest filtrowany (karta pokazuje '(filtered: excludes {n} ignored paths)') i nie odtworzy dokładnie oryginałów. Wyczyść ścieżki ignorowane, aby uzyskać kompletny patch.
Czy JSON Patch jest tym samym co JSON Merge Patch (RFC 7396)?
Nie. RFC 6902 (JSON Patch) to uporządkowana tablica operacji — jawna i odwracalna. RFC 7396 (Merge Patch) to pojedynczy dokument scalający — prostszy, ale nie może odróżnić usunięcia od ustawienia wartości null. JSON Diff zwraca RFC 6902.
Jak porównywać duże pliki JSON (>10 MB)?
Pliki powyżej ~5 MB przekraczają praktyczną pamięć przeglądarki. Tryb live wyłącza się przy 200 KB; dla plików wielomegabajtowych użyj wiersza poleceń jq lub fast-json-patch w Node.
Czy narzędzie wysyła mój JSON na serwer?
Nie. Całe porównanie działa lokalnie w przeglądarce. Dane wejściowe nigdy nie są zapisywane na dysku, w sieci, localStorage ani parametrach URL. Odświeżenie strony je czyści. Przycisk Share Link zapisuje tylko konfigurację (tryb tablicy, ścieżki ignorowane) — nigdy Twoje dane.
Dlaczego 42 różni się od "42" w diffie?
JSON Diff jest ścisły pod względem typów: liczba 42 i ciąg "42" nie są równe. Wychwytuje to dryf serializacji backendu (niektóre endpointy zwracają numeryczne ID, inne ciągi) — diff oznacza to jako modyfikację 'type'.
Czy mogę porównywać JSON z komentarzami (JSONC) lub przecinkami na końcu?
Standardowy JSON (RFC 8259) nie pozwala na komentarze ani przecinki końcowe. Narzędzie używa natywnego JSON.parse, który odrzuca obie formy. Usuń komentarze najpierw za pomocą Formatera JSON.
Jak porównywać zagnieżdżone tablice obiektów po kluczu jak id?
Ustaw tryb tablicy na 'Dopasuj po kluczu' i wpisz id. Diff wyrównuje elementy według wartości id. V1 stosuje to samo pole klucza na każdym poziomie zagnieżdżenia tablic; wewnętrzne tablice bez tego pola wracają do trybu sekwencyjnego i emitują ostrzeżenie.
Czy diff obsługuje precyzję zmiennoprzecinkową (0.1 + 0.2)?
Tak, dzięki Tolerancji numerycznej. Domyślnie jest 0 z Object.is — więc -0 vs +0 są oznaczane jako różne. Ustaw tolerancję na małe epsilon (np. 1e-9), a 0.1 + 0.2 będzie równe 0.3. Tolerancja dotyczy tylko liści numerycznych.

Powiązane narzędzia

Zobacz wszystkie narzędzia →