Comparador Diff JSON

1. 1Adicione o primeiro documentoCole JSON na caixa da esquerda ou solte um arquivo .json na área de carregamento. Solte dois arquivos de uma vez e eles são emparelhados automaticamente: nomes como users.before.json e users.after.json são reconhecidos, e o lado mais antigo fica à esquerda.
2. 2Adicione o segundo documentoCole ou solte o segundo documento na caixa da direita. Use Trocar lados se os dois ficaram ao contrário.
3. 3Leia as diferençasA comparação roda enquanto você digita. Alterne entre as visualizações lado a lado, em linha e por caminho; as seções sem alterações ficam recolhidas até as abrir, e os botões anterior e seguinte saltam entre alterações.
4. 4Ajuste o que conta como diferençaIgnore a ordem dos arrays, as maiúsculas ou os espaços; defina uma tolerância numérica; indique chaves ou caminhos a saltar; ou emparelhe itens por um campo id para que uma lista reordenada seja lida como reordenada e não como reescrita.
5. 5Exporte o resultadoCopie o resumo, transfira um patch JSON RFC 6902 que transforma o documento da esquerda no da direita, ou transfira um relatório Markdown para colar num pull request ou num ticket.

Encontre as alterações exatas entre dois objetos JSON, incluindo chaves adicionadas, removidas e alteradas, com filtragem rápida e diagnósticos claros. Cole ou solte dois documentos e a comparação roda no seu dispositivo enquanto você digita: cada diferença é relatada pelo seu caminho exato, os arrays são emparelhados elemento a elemento em vez de despejados como um bloco, e o resultado pode sair como patch JSON, relatório Markdown ou resumo copiável.

• Diferenças com caminho exato — Cada alteração é endereçada por um JSON Pointer, portanto users/1/name significa esse campo desse item e mais nada. Uma chave que contenha literalmente um ponto ou uma barra é escapada em vez de se confundir com o caminho em volta.
• Três formas de ler — Lado a lado para percorrer, em linha para uma visualização ao estilo patch, ou uma lista simples por caminho para ir direto ao que mudou. As seções sem alterações ficam recolhidas até abrir uma.
• Quatro tipos de alteração — Adicionado, removido, alterado e tipo alterado. Um valor que passa de "3" para 3 é assinalado à parte, porque é a alteração com maior probabilidade de partir o que ler o documento a seguir.
• Exportações que servem — Um patch JSON RFC 6902 que outras ferramentas podem aplicar, um relatório Markdown para um pull request, ou um resumo simples para uma mensagem. A página que substitui não exportava nada.

É esta a parte que separa um diff JSON útil de um frustrante. Comparar dois arrays posição a posição só funciona enquanto nada for inserido ou removido: acrescente um item ao início de uma lista de mil e todos os seguintes ficam alinhados com o vizinho errado, por isso uma alteração de um item é relatada como mil.

Por isso os arrays são alinhados antes de serem comparados, com aquela das quatro estratégias que servir. A que correu é mostrada junto ao resumo, porque a primeira pergunta que qualquer pessoa faz perante um diff de arrays é por que motivo dois itens concretos foram emparelhados.

• Por id — Indique um campo em Emparelhar itens e os elementos alinham-se pelo seu valor. Uma coleção que voltou de uma API noutra ordem lê-se então como reordenada, relatando apenas o registro verdadeiramente alterado. Só é usado quando todos os elementos têm o campo e nenhum valor se repete: uma chave não única produziria um emparelhamento seguro, arrumado e errado, por isso é recusado em vez de adivinhado.
• Por subsequência comum mais longa — O comportamento por padrão. O prefixo e o sufixo comuns são emparelhados primeiro, e depois o meio é alinhado para que o menor número possível de itens conte como inserido ou removido. Uma inserção é uma adição; uma eliminação é uma remoção; todo o resto continua alinhado.
• Como conjunto — Ative Ignorar ordem dos arrays e as duas listas são comparadas como coleções sem ordem, por isso itens que apenas se moveram deixam de ser diferenças.
• Por posição — A resposta honesta para duas listas com quase nada em comum, onde qualquer emparelhamento é arbitrário e fingir o contrário só acrescenta ruído.

A comparação por padrão é estrita: cada valor, cada tipo e cada posição de array tem de coincidir. Cada opção abaixo relaxa uma coisa concreta, e o relatório registra quais estavam ativas, para que um resultado possa sempre ser relido mais tarde.

• Ignorar ordem dos arrays — Tratar os arrays como coleções sem ordem. Útil para listas de etiquetas, conjuntos de permissões e tudo aquilo cuja ordem não significa nada.
• Ignorar maiúsculas — Comparar strings sem levar em conta as maiúsculas. Útil para rótulos e valores de enumeração que mudaram de estilo mas não de sentido.
• Ignorar espaços — Aparar as strings e reduzir sequências de espaços antes de comparar, para que uma descrição reformatada não se leia como uma reescrita.
• Tolerância numérica — Escolha quão próximos dois números têm de estar para contarem como iguais, de exato até 1. Com 0,0001 o ruído de arredondamento desaparece, mas uma alteração real de preço não.
• Ignorar chaves — Indique chaves — updatedAt, requestId, etag — e são saltadas onde quer que apareçam, a qualquer profundidade. É isto que transforma duas capturas de uma API num diff legível.
• Ignorar caminhos — Saltar um local específico em vez de um nome. São aceitos curingas: /users/*/lastSeen salta esse campo para todos os usuários e /meta/** salta tudo o que está sob meta.
• Permitir comentários e vírgulas finais — Aceita JSONC, para comparar arquivos de configuração tal como estão escritos. Soltar um arquivo .jsonc ativa isto por si.
• Comparar enquanto você digita — Ativo por padrão. Desative-o em documentos muito grandes se preferir comparar a pedido; o botão passa a indicar quantos resultados estão desatualizados.

Cada diferença leva um JSON Pointer RFC 6901 — /users/1/name em vez de users.1.name. A distinção pesa mais do que parece, porque um caminho construído juntando chaves com pontos torna-se ambíguo assim que uma chave contém um.

Um documento com uma chave chamada literalmente a.b e um documento com um a aninhado que contém b produzem o mesmo caminho com pontos, portanto dois locais realmente diferentes reclamam o mesmo endereço e nenhum pode ser resolvido de volta a um nó. Um pointer escapa o separador em vez de o reservar: ~ passa a ~0 e / passa a ~1, de modo que cada caminho resolve exatamente para um lugar. É isso que torna o patch exportado aplicável, os botões de salto possíveis e o resultado utilizável por outra ferramenta.

• Na tela — Os caminhos aparecem numa forma mais amigável — $.users[1].name — porque é o que melhor se lê. O que é exportado é o pointer.
• No patch — Cada operação é endereçada pelo seu pointer, o que faz do arquivo um patch RFC 6902 padrão e não algo que só esta ferramenta entende.

Um diff é normalmente a prova de outra coisa — uma revisão, um ticket, uma verificação de implantação — por isso tem de conseguir sair da página. Três exportações cobrem as formas como isso acontece, e as três estão disponíveis no plano gratuito.

• Patch JSON (RFC 6902) — Uma lista padrão de operações add, remove e replace que transforma o documento da esquerda no da direita. As operações sobre arrays são ordenadas para que os índices continuem válidos à medida que o patch é aplicado: primeiro tudo o que está dentro de um item, depois as remoções a partir do fim, depois as inserções a partir do início.
• Relatório Markdown — Uma tabela de resumo, as configurações usadas e uma linha por diferença com o caminho, o tipo de alteração e ambos os valores. Valores que contêm uma barra vertical são escapados, por isso uma linha da tabela nunca se pode dividir em colunas erradas.
• Resumo copiável — Uma lista em texto simples com prefixos +, - e ~, para uma mensagem de chat ou uma nota de commit.
• Um ZIP para o lote — Com Pro, cada comparação da fila exporta o seu relatório e o seu patch para um único arquivo.

O JSON permite que um objeto declare a mesma chave duas vezes. Todos os analisadores existentes aceitam-no e mantêm silenciosamente o último valor, o que significa que dois documentos podem diferir numa chave que nenhuma comparação alguma vez conseguiria ver: a diferença desaparece antes de a comparação começar.

Ambos os lados são analisados à procura de chaves repetidas e é-lhe dito qual e onde. A análise roda depois de o resultado aparecer, por isso nunca atrasa a resposta. Outros dois casos silenciosos são tratados da mesma forma: os números são comparados por valor e não pela forma como foram escritos, portanto 1, 1.0 e 1e0 são um só valor e -0 é igual a 0; e as chaves de um objeto são comparadas como conjunto, por isso reordená-las não é uma alteração.

• A mesma chave duas vezes — Relatada como aviso, indicando a chave e a sua localização, no lado em que aparece.
• Números escritos de outra forma — 1 e 1.0 são o mesmo valor e não são relatados como alteração.
• Chaves noutra ordem — Os objetos não têm ordem por definição, por isso um objeto reordenado compara-se como idêntico.
• Qualquer raiz, não só um objeto — Um array, uma string, um número, true, false ou null na raiz comparam-se normalmente.

A ferramenta abre exatamente os formatos abaixo e recusa todos os outros no momento em que escolhe o arquivo, em vez de o deixar chegar ao analisador e falhar. Um arquivo recusado é nomeado, e a ferramenta que o converte também.

• JSON, GeoJSON, source maps, texto simples — .json, .geojson, .map e .txt abrem diretamente. Os arquivos são reconhecidos pela extensão, não pelo tipo que o seu sistema comunica — que muitas vezes não é nenhum.
• JSONC — .jsonc abre aceitando comentários e vírgulas finais automaticamente. A opção também pode ser ligada à mão para um .json que os contenha.
• YAML e XML — Recusados, com um link para o conversor YAML para JSON ou XML para JSON. Converta primeiro, compare depois.
• CSV e Excel — Recusados, com um link para CSV para JSON ou Excel para JSON.

A comparação roda fora da thread principal, por isso a página continua respondendo enquanto trabalha e Cancelar cancela mesmo — incluindo durante a fase mais lenta e não apenas entre passos. O progresso é real: conta nós percorridos, não segundos decorridos.

A lista de resultados é desenhada por janela em vez de construída por inteiro. Uma comparação com milhares de diferenças desenha apenas as linhas na tela, e é por isso que um diff muito grande se percorre com fluidez em vez de congelar a aba enquanto se criam dezenas de milhares de elementos. As seções sem alterações nem sequer são construídas até abrir uma.

• Enquanto você digita — As edições são agrupadas numa só comparação em vez de uma por tecla, e só roda uma de cada vez.
• Cancelar — Para numa fração de segundo, em qualquer ponto da execução.
• As contagens continuam exatas — Acima de 100.000 diferenças a lista deixa de crescer mas os totais não, e a página indica que a lista foi truncada. Um resumo que relatasse a menos em silêncio seria pior do que não ter resumo.

Um par de 10 MB é analisado, comparado e produz o seu patch em bem menos de um segundo, fora da thread principal, por isso a página mantém-se responsiva enquanto trabalha.

Arquivos de configuração, respostas de API e dados exportados mudam entre versões, e a parte interessante quase nunca é visível no texto em bruto. Uma comparação estrutural diz exatamente que chaves foram adicionadas, removidas ou mudaram de tipo sem ler nenhum dos dois documentos, e é isso que a torna útil numa revisão, num relatório de erro ou numa auditoria.

• Revisões mais rápidas — Detecte alterações estruturais em configurações e payloads sem uma leitura linha a linha, e cole o relatório Markdown diretamente no pull request.
• Verificação de regressões — Compare uma resposta esperada com uma real, ignore os campos que mudam sempre e veja apenas o que se moveu de fato.
• Migrações e auditorias — Confirme que uma transformação manteve todos os campos que devia, e produza um patch como registro do que alterou.
• No seu dispositivo, não nos nossos servidores — Credenciais, registros de clientes e payloads internos são comparados onde já estão: nada é enviado e nada é armazenado.

O plano gratuito é limitado em escala, nunca em funções: todas as opções de comparação, as três visualizações e todas as exportações de um par funcionam no plano gratuito. O Pro sobe o teto e acrescenta o lote.

• Gratuito — Um par de cada vez, até 10 MB por lado. Todas as opções, as três visualizações e as exportações de patch JSON, Markdown e resumo.
• Pro — Documentos até ao que o seu dispositivo aguentar, e até 50 pares em fila ao mesmo tempo — emparelhados por nome, com todos os relatórios e patches num único ZIP.
• Se um arquivo for grande demais — A recusa indica o tamanho real e o limite, e leva ao Minificador JSON: um documento indentado a dois espaços é muitas vezes sobretudo indentação, e minificá-lo é frequentemente a solução completa.

• Formatador JSON
• Validador JSON
• Juntar JSON
• Minificador JSON
• Visualizador JSON
• YAML para JSON