JSON Patch Playground

Work with RFC 6902 patches: apply one to a document, write one from two documents, or turn one around so it undoes itself.

Voltar para todas as ferramentas

Mode Indentacao

Document

Patch

Result

The result appears here.

Affected paths

The paths a patch touches appear here.

Funciona inteiramente no seu navegador.

Sobre esta ferramenta

A JSON Patch is a list of operations that turns one document into another. RFC 6902 defines it, and APIs that accept partial updates ask for it. This page does the four things that list is actually used for. Apply runs a patch against a document and prints the result. Generate compares two documents and writes the patch that turns the first into the second. Reverse runs a patch and writes the patch that undoes it, which needs the original document, because a remove says what to delete and not what was there. Check reads a patch on its own and reports whether it is well formed, which is the test worth running before sending one anywhere. All six operations are supported: add, remove, replace, move, copy and test. A patch is all or nothing, exactly as the specification requires: if one operation fails then none of them are applied, and the page says which one stopped and why. Values keep the text you wrote them with, so a twenty digit id survives a patch that never mentioned it and 1.0 stays 1.0. Comparison, which is what test asks and what generation uses to decide a value changed, reads 1 and 1.0 as the same number and ignores the order of object keys, while array order is data and is compared position by position.

Como usar

Paste the document on the left and the patch on the right, or load the sample.
Choose what to do: apply the patch, generate one from two documents, reverse one, or check a patch on its own.
Read the affected paths, then copy or download the result.

Perguntas frequentes

What happens if one operation in the patch fails?

Nothing is applied. RFC 6902 calls a patch atomic: either every operation succeeds or the document is left exactly as it was. A half applied patch would be a document neither side asked for, so this page names the operation that stopped, counting from one in the order the patch wrote them, and leaves your input untouched. A test that does not match is the ordinary way this happens, and it is the point of test: it is how a patch refuses to overwrite a document that has changed since the patch was written.

Why does a generated patch never use move or copy?

Because a move is a guess about intent. Two documents can only show that a value is gone from one place and present in another, not that anyone moved it, and a tool that guesses will eventually write a patch that means something the data never said. Arrays are compared position by position for the same reason, so inserting an element at the front produces a replace for each element after it rather than one clever move. Patches written by hand may use all six operations, and this page applies, reverses and checks all of them.

Can every patch be reversed?

Yes, but only together with the document it was written against. The patch alone is not enough: remove says what to delete and not what was there, and an add onto a key that already exists says nothing about the value it replaced. Running the patch forward is what recovers both, which is why reversing here reads the document in the left pane. An append written as a dash has no index until it lands either, so the reverse names the position the value actually took.

JSON Patch Playground

Atalhos de teclado

Dados locais

Arquivos abertos recentemente

Compartilhar via link

Abrir o link compartilhado em