JSON para JavaScript Object

JSON surgiu diretamente do JavaScript: Douglas Crockford identificou um subconjunto da sintaxe de objeto literal do JavaScript que podia ser usado como formato de troca de dados e o chamou de JavaScript Object Notation. Ironicamente, JSON e objeto JavaScript não são a mesma coisa. Um objeto JavaScript pode conter funções, referências circulares, valores `undefined`, instâncias de `Date`, `Map`, `Set`, `RegExp` e `Symbol` — nada disso existe em JSON. Quando um objeto JavaScript passa pelo `JSON.stringify`, funções e `undefined` são silenciosamente descartados, e objetos `Date` viram strings ISO 8601 sem nenhum aviso.

`JSON.parse` e `JSON.stringify` são os dois métodos da API global JSON do JavaScript, disponíveis em todos os navegadores modernos e no Node.js sem nenhum import necessário. `JSON.parse` aceita um segundo argumento chamado `reviver`: uma função que transforma chaves e valores durante o parsing, útil para converter strings de data de volta para instâncias de `Date`. `JSON.stringify` aceita `replacer` (função ou array de chaves para incluir na saída) e `space` (número de espaços ou string de indentação).

Nunca use `eval()` para parsear JSON, mesmo que funcione tecnicamente. `eval` executa qualquer código JavaScript contido na string, abrindo uma brecha de segurança grave se o JSON vier de uma fonte não confiável. Antes de `JSON.parse` existir (antes do ES5 em 2009), `eval` era a única opção disponível, mas hoje não há nenhuma justificativa para usá-lo. Outra armadilha é chamar `JSON.stringify` em um objeto com referências circulares: a função lança um `TypeError` imediatamente.

Esta ferramenta converte o JSON que você cola em código JavaScript pronto para usar, com exemplos de `JSON.parse` para leitura e `JSON.stringify` para serialização. O código gerado é compatível com navegadores modernos (ES2015+) e Node.js. Para deep clone de objetos em ambientes modernos, considere `structuredClone()` como alternativa ao padrão `JSON.parse(JSON.stringify(obj))`: é semanticamente mais correto e geralmente mais rápido.

JSON grew directly from JavaScript: Douglas Crockford identified a subset of JavaScript's object literal syntax that could serve as a data exchange format and called it JavaScript Object Notation. Ironically, JSON and a JavaScript object are not the same thing. A JavaScript object can hold functions, circular references, `undefined` values, `Date` instances, `Map`, `Set`, `RegExp`, and `Symbol` — none of which exist in JSON. When a JavaScript object goes through `JSON.stringify`, functions and `undefined` are silently dropped, and `Date` instances become ISO 8601 strings with no warning.

`JSON.parse` and `JSON.stringify` are the two methods on JavaScript's built-in JSON object, available in every modern browser and in Node.js without any import. `JSON.parse` accepts a second argument called a `reviver`: a function that transforms keys and values during parsing, useful for converting date strings back into `Date` instances. `JSON.stringify` accepts a `replacer` (function or array of keys to include in the output) and a `space` argument (number of spaces or indentation string).

Never use `eval()` to parse JSON, even though it works technically. `eval` executes any JavaScript code inside the string, opening a serious security hole if the JSON comes from an untrusted source. Before `JSON.parse` existed (before ES5 in 2009), `eval` was the only available option, but today there is no justification for using it. Another trap is calling `JSON.stringify` on an object with circular references: the function throws a `TypeError` immediately.

This tool converts the JSON you paste into ready-to-use JavaScript code, with examples of `JSON.parse` for reading and `JSON.stringify` for serialization. The generated code is compatible with modern browsers (ES2015+) and Node.js. For deep cloning in modern environments, consider `structuredClone()` as an alternative to the `JSON.parse(JSON.stringify(obj))` pattern: it is semantically more correct and generally faster.

JSON surgió directamente de JavaScript: Douglas Crockford identificó un subconjunto de la sintaxis de literal de objeto de JavaScript que podía usarse como formato de intercambio de datos y lo llamó JavaScript Object Notation. Irónicamente, JSON y un objeto JavaScript no son lo mismo. Un objeto JavaScript puede contener funciones, referencias circulares, valores `undefined`, instancias de `Date`, `Map`, `Set`, `RegExp` y `Symbol` — nada de eso existe en JSON. Cuando un objeto JavaScript pasa por `JSON.stringify`, las funciones y el `undefined` se descartan silenciosamente, y las instancias de `Date` se convierten en cadenas ISO 8601 sin ningún aviso.

`JSON.parse` y `JSON.stringify` son los dos métodos del objeto JSON integrado de JavaScript, disponibles en todos los navegadores modernos y en Node.js sin ningún import. `JSON.parse` acepta un segundo argumento llamado `reviver`: una función que transforma claves y valores durante el análisis, útil para convertir cadenas de fecha de vuelta en instancias de `Date`. `JSON.stringify` acepta un `replacer` (función o array de claves a incluir en la salida) y un argumento `space` (número de espacios o cadena de sangría).

Nunca uses `eval()` para analizar JSON, aunque técnicamente funcione. `eval` ejecuta cualquier código JavaScript de la cadena, abriendo una brecha de seguridad grave si el JSON proviene de una fuente no confiable. Antes de que existiera `JSON.parse` (antes de ES5 en 2009), `eval` era la única opción disponible, pero hoy no hay ninguna justificación para usarlo. Otra trampa es llamar a `JSON.stringify` con un objeto que tiene referencias circulares: la función lanza un `TypeError` de inmediato.

Esta herramienta convierte el JSON que pegues en código JavaScript listo para usar, con ejemplos de `JSON.parse` para la lectura y `JSON.stringify` para la serialización. El código generado es compatible con navegadores modernos (ES2015+) y Node.js. Para la clonación profunda en entornos modernos, considera `structuredClone()` como alternativa al patrón `JSON.parse(JSON.stringify(obj))`: es semánticamente más correcto y generalmente más rápido.