JSON Stringify

Strumento online gratuito JSON Stringify / Parse. Con un clic serializza oggetti JSON in stringhe con apici pronte per essere incorporate in codice o URL; supporta anche la modalità Parse inversa per ripristinare gli oggetti JSON.

Raccomandazioni correlate

Cos'è JSON Stringify (Serializzazione JSON e Incorporazione in Stringa)?

JSON Stringify (serializzazione JSON) è la conversione di un oggetto JSON (o array, valore) in una rappresentazione di stringa conforme a RFC 8259. In JavaScript, il modo standard è chiamare `JSON.stringify(obj)`, che produce una stringa con apici doppi come `{"name":"Alice"}` - questo completa 'oggetto → stringa', e il risultato è esso stesso JSON valido che può essere ri-analizzato da qualsiasi JSON.parse().

Ma nei progetti ingegneristici reali, gli sviluppatori spesso hanno bisogno di 'incorporare' ulteriormente il risultato della serializzazione in un altro testo - questo è ciò che lo strumento JSON Stringify risolve veramente: ① Inserire la stringa JSON in codice sorgente JavaScript / Java / Python / Go come inizializzatore di variabile; ② Salvare la stringa JSON in una colonna TEXT del database, in un valore Redis, o in un payload di coda di messaggi; ③ Usare la stringa JSON come valore di un altro campo JSON ('JSON annidato', es. log di audit o risposte API che avvolgono il corpo completo di una chiamata precedente); ④ Inserire la stringa JSON in parametri di query URL o header HTTP per la trasmissione tra servizi.

In questi scenari di 'doppia incorporazione', l'output grezzo di `JSON.stringify()` non è sufficiente - i newline, gli apici doppi e le barre inverse all'interno della stringa devono essere nuovamente escape, altrimenti romperanno la struttura esterna. Lo strumento JSON Stringify di GeekFormat esegue automaticamente un 'escape di incorporazione' sopra la serializzazione standard: avvolge il risultato in un'altra coppia di apici doppi e fa l'escape con barra inversa di tutti i caratteri speciali (", \, \n, \r, \t, \b, \f) all'interno, in modo che l'output possa essere incollato in qualsiasi codice o testo senza rompere la sintassi esterna. Combinato con la modalità Parse, puoi anche ripristinare completamente tali stringhe con escape in oggetti JSON leggibili. L'intero processo avviene localmente nel browser; nulla viene caricato.

Casi d'uso

  • Serializza oggetti JSON come letterali stringa e assegnali direttamente a variabili JavaScript / Java / Python / Go
  • Annida JSON da risposte API in un altro campo JSON (un valore stringa all'interno del JSON esterno)
  • Salva stringhe JSON in colonne TEXT del DB, valori Redis, payload di code di messaggi - ovunque sia richiesta una stringa
  • Trasmetti stringhe JSON come parametri di query URL o parti di un path tra servizi
  • Incorpora snippet di codice JSON leggibili in documenti Markdown, HTML, LaTeX
  • Analizza inversamente le stringhe JSON in log/file di configurazione in strutture di oggetto per la revisione umana

Come utilizzare

  1. Incolla il contenuto JSON (oggetto / array / valore) nella casella di input sinistra, o fai clic su 'Esempio' per caricare un JSON tipico, o carica un file .json/.txt
  2. Scegli la modalità di elaborazione: Stringify predefinita (oggetto → stringa incorporabile); per l'analisi inversa, fai clic su 'Parse' per passare a stringa → oggetto
  3. In modalità Stringify, passa tra formato 'Pretty' (indentazione 2 spazi) o 'Compact' (riga singola) secondo necessità
  4. La casella di output destra si aggiorna in tempo reale; dopo la conferma, fai clic su 'Copia' per incollare la stringa in codice / documenti, o fai clic su 'Scarica' per salvare come stringified.txt / parsed.json

Funzionalità

  • Modalità bidirezionale: supporta Stringify (oggetto JSON → stringa con apici incorporabile) e Parse (stringa con apici → oggetto JSON)
  • Escape di incorporazione intelligente: sopra il JSON.stringify standard, avvolge automaticamente con apici e fa l'escape di ", \, \n, \r, \t e altri caratteri speciali; incolla direttamente in codice o testo
  • Indentazione configurabile: supporta indentazione 0/2 spazi e modalità compatta a riga singola, adattandosi a diversi stili di codice e necessità di ottimizzazione delle dimensioni
  • Incorporazione diretta nel codice: il risultato della serializzazione può essere assegnato direttamente a variabili JavaScript, Java, Python, Go e altri linguaggi principali senza escape manuale
  • Ottimizzato per scenario URL / database: le stringhe di output possono essere inserite in modo sicuro in parametri di query, body HTTP, colonne TEXT del DB, documenti Markdown
  • Ripristino inverso completo Parse: rimuove correttamente gli apici esterni e fa l'unescape di tutte le sequenze \n, \t, \", \\ in un oggetto JSON standard
  • Elaborazione locale per la privacy: analisi, escape, unescape e formattazione avvengono localmente nel browser, nessun input inviato a un server
  • Caricamento di file ed esempi: supporta il caricamento di file .json/.txt o il caricamento di esempi con un clic per la verifica rapida degli effetti dell'escape

Esempi di codice

Incorporazione nel codice sorgente con JavaScript JSON.stringify

javascript
// In business devi incorporare uno snippet JSON come letterale stringa nel codice JS
const data = { name: 'Alice', age: 30, tags: ['dev', 'writer'] };

// Serializzazione standard
const json = JSON.stringify(data, null, 2);

// Escape di incorporazione: avvolgi con apici esterni + escape " \ \n \r \t interni
const embedded = '"' + json
  .replace(/\\/g, '\\\\')
  .replace(/"/g, '\\"')
  .replace(/\n/g, '\\n')
  .replace(/\r/g, '\\r')
  .replace(/\t/g, '\\t') + '"';

// Analisi inversa
const restored = JSON.parse(embedded);
console.log(restored.name); // 'Alice'

Incorporazione con Python json.dumps + unescape

python
import json

data = {"name": "Alice", "age": 30, "tags": ["dev", "writer"]}

# Serializza e indenta
pretty = json.dumps(data, indent=2, ensure_ascii=False)
print(pretty)

# Escape di incorporazione: json.dumps fa l'escape completo per te
embedded = json.dumps(pretty)  # il valore del letterale stringa
print(embedded)  # '"{\\n  \\"name\\": \\"Alice\\",...\\n}"'

# Analisi inversa
restored = json.loads(json.loads(embedded))
print(restored["name"])  # Alice

Incorporare JSON come stringa nella riga di comando con jq

bash
# Serializza data.json in una stringa con apici incorporabile
jq -Rs . data.json

# Spiegazione: -R (raw input) + -s (slurp) tratta l'intero file come una stringa,
# poi . lo converte in un letterale stringa JSON con " \ \n auto-escape all'interno

# Inverso: analizza una stringa in JSON
echo '"{\"name\":\"Alice\"}"' | jq -r .

Domande frequenti

JSON Stringify è uguale a JSON.stringify()?

La logica sottostante è la stessa - entrambi serializzano un oggetto JSON in una stringa. La differenza è che questo strumento, sopra la serializzazione standard, avvolge anche il risultato in un'altra coppia di apici doppi e fa l'escape con barra inversa di tutti i caratteri speciali interni, in modo che l'output possa essere incollato direttamente in codice, URL e campi di database come 'letterale stringa' senza scrivere manualmente gli escape.

Qual è la differenza tra Stringify e JSON Escape?

JSON Stringify converte un intero oggetto JSON in una stringa con apici incorporabile. JSON Escape aggiunge solo escape con barra inversa ai caratteri speciali in una stringa esistente, senza modificare la struttura dell'oggetto. Il primo mira a 'oggetto → stringa incorporabile'; il secondo a 'stringa → stringa sicura'. Quando il tuo input è già JSON valido e devi incorporarlo nel codice, usa Stringify; quando il tuo input è uno snippet di testo semplice, usa Escape.

Stringify renderà il JSON meno leggibile?

Nessun dato va perso. Per impostazione predefinita mantiene l'indentazione di 2 spazi e le newline, quindi il risultato è ancora JSON valido e leggibile. Se hai bisogno di una stringa più corta a riga singola per scenari di incorporazione sensibili alle dimensioni, passa alla modalità 'Compact'.

La modalità Parse può ripristinare stringhe con sequenze \n \t \"?

Sì. La modalità Parse rileva automaticamente se l'input è avvolto in apici esterni, fa l'unescape di tutte le sequenze comuni come \n, \r, \t, \", \\ secondo le regole JSON, e ri-analizza in un oggetto JSON standard. Nota che l'input deve essere una stringa legalmente escape, altrimenti viene segnalato un SyntaxError.

L'output di Stringify può andare direttamente in un URL?

Sì, ma raccomandiamo un passaggio aggiuntivo di URL Encode. Stringify gestisce i caratteri di sintassi JSON (", \, newline), mentre gli URL trattano anche &, =, spazio, cinese come caratteri riservati. Per i parametri URL, dovresti chiamare anche encodeURIComponent - questo strumento è responsabile solo della sicurezza a livello JSON.

Come gestire JSON annidato (una stringa JSON come valore di un altro JSON)?

La modalità Stringify prima serializza il JSON interno normalmente per ottenere una stringa, poi esegue un 'escape di incorporazione' su quella stringa (apici più esterni, escape interno di ", \, \n). Il risultato è un 'valore di campo stringa valido del JSON esterno' che può essere incollato direttamente nel JSON esterno. La modalità Parse fa l'opposto.

Lo strumento modifica l'ordine dei campi o i nomi delle chiavi?

No. Stringify emette rigorosamente nell'ordine corrente dei campi dell'oggetto di input, e non cambia case, spaziatura o singolare/plurale nei nomi delle chiavi. Se hai bisogno di un ordine unificato delle chiavi, esegui prima JSON Sort; se le chiavi contengono cinese o caratteri speciali, lo strumento le emette secondo la specifica JSON.

Il risultato può essere salvato direttamente come file?

Sì. In modalità Stringify, cliccando su 'Scarica' salva come stringified.txt (stringa semplice); in modalità Parse, salva come parsed.json (file JSON standard). Puoi anche copiare negli appunti e incollare in codice o documenti.

Ci sarà un ritardo con input di alcuni MB?

Questo strumento è ottimizzato per input entro 1-3 MB; input più grandi (es. 10 MB+) possono ancora essere elaborati ma saranno limitati dalla memoria del browser. Raccomandazioni: ① esegui JSON.stringify localmente in uno script Node.js per file enormi; ② dividi in batch più piccoli per usare questo strumento; ③ chiudi altre schede del browser per liberare memoria.

È normale avere cinese/emoji nell'output di Stringify?

Sì. La specifica JSON permette ai caratteri Unicode non-ASCII (incluso cinese, emoji) di apparire direttamente nelle stringhe, e non saranno auto-escape in \uXXXX. Solo ", \ e i caratteri di controllo vengono escape. Se hai bisogno della forma \uXXXX (es. per compatibilità con protocolli legacy), puoi post-elaborare l'output nel codice.

Lo strumento carica il mio JSON su un server?

No. Serializzazione, deserializzazione, escape, unescape e formattazione avvengono tutti localmente nel browser; né l'input né i risultati intermedi vengono inviati a nessun server. Funziona offline, adatto per elaborare configurazioni interne, risposte API e JSON sensibili.

Qual è il miglior ordine di utilizzo con JSON Compress e JSON Formatter?

Catena raccomandata: ① Riparare JSON (pulire JSON illegale) → ② Formattare JSON (standardizzare indentazione) → ③ JSON Sort (unificare ordine delle chiavi per confronto) → ④ Questo strumento Stringify (incorporare in stringa) → ⑤ JSON Escape (escape a livello di carattere per snippet di testo semplice). Scegli i passi che ti servono.

Risoluzione dei problemi

Stringify mostra errore 'Invalid JSON'

Causa: l'input non è JSON valido, es. virgole finali, apici singoli, nomi di chiavi senza apici, commenti. Soluzione: usa prima lo strumento Riparare JSON di GeekFormat per pulirlo, poi torna a Stringify; o rimuovi manualmente i caratteri illegali in un editor e riprova.

L'output non è JSON valido dopo Parse

Causa: la stringa di input non è correttamente avvolta in apici esterni, o i caratteri di escape interni sono rotti (es. alcuni editor rimuovono automaticamente \). Soluzione: controlla che l'input inizi con " o '; cerca caratteri \ non abbinati; ripristina prima con lo strumento Riparare JSON, poi Parse.

L'ordine dei campi cambia dopo Stringify

Causa: alcuni browser ordinano automaticamente le chiavi intere pure (es. "0": ..., "1": ...) per ordine numerico. Soluzione: cambia le chiavi intere in chiavi stringa ("k0", "k1") prima dell'elaborazione; oppure usa prima lo strumento JSON Sort per disporre le chiavi nell'ordine desiderato, poi Stringify.

SyntaxError durante l'incorporazione nel codice JS

Causa: l'unione manuale ha perso escape con barra inversa, o l'apice esterno ha usato apici singoli mentre la stringa contiene apici singoli non escape. Soluzione: copia direttamente l'output della modalità Stringify di questo strumento, senza modifica manuale; se devi usare apici singoli, sostituisci tutti gli ' interni con \'.

L'output mostra \uXXXX invece di cinese

Causa: questo strumento emette caratteri originali per impostazione predefinita (cinese/emoji mostrato direttamente); se vedi \uXXXX, il tuo input era esso stesso già una stringa con escape. Soluzione: fai l'unescape inverso una volta in modalità Parse, o nel codice usa ensure_ascii=False (Python) / un serializzatore che non fa l'escape.

File di grandi dimensioni (10 MB+) bloccano o fanno crashare il browser

Causa: analizzare un testo grande con JSON.parse in una volta occupa molta memoria. Soluzione: taglia l'input in batch da 1-2 MB; elabora file enormi localmente con Node.js (`JSON.stringify`) o Python (`json.dumps`); usa questo strumento per piccole verifiche manuali in seguito.

Glossario

JSON.stringify
Metodo integrato di JavaScript che serializza un valore JS in una stringa JSON; il risultato restituito è esso stesso JSON valido che può essere ri-analizzato da JSON.parse, ma per impostazione predefinita non contiene apici esterni o escape aggiuntivo.
JSON.parse
Metodo integrato di JavaScript che analizza una stringa conforme a RFC 8259 in un valore JS; lancia SyntaxError immediatamente su qualsiasi errore di sintassi.
Serializzare
Il processo di conversione di una struttura dati in memoria (oggetto/array) in un formato testo memorizzabile/trasmissibile (stringa JSON). JSON Stringify è l'implementazione più comune.
Deserializzare
L'inverso della serializzazione - ripristinare una stringa JSON in un oggetto/array in memoria. Corrisponde a JSON.parse.
Escape
Aggiungere una barra inversa prima dei caratteri speciali (" → \", \ → \\, \n → \n, ecc.) in modo che la stringa possa essere incorporata in modo sicuro in codice o testo esterno senza rompere la sintassi esterna.
Letterale stringa
Una costante stringa avvolta in una coppia di apici nel codice sorgente. La forma di output finale di JSON Stringify è esattamente il letterale stringa di JS/Java/Python e altri linguaggi.
Doppio Escape
Una stringa che è già stata escape una volta viene nuovamente escape quando viene incorporata in un altro strato. Ad esempio, `\n` con doppio escape diventa `\\n` - un bug comune derivante dall'unione manuale nei log e nell'archiviazione del database.
Escape Unicode (\uXXXX)
JSON permette `\uXXXX` per rappresentare qualsiasi carattere Unicode. La libreria standard JS non converte automaticamente cinese/emoji in `\uXXXX` a meno che `ensure_ascii=True` non sia esplicitamente specificato.
ensure_ascii (Python)
Parametro del modulo json.dumps di Python. Quando True (predefinito), converte tutti i caratteri non-ASCII in `\uXXXX`; quando False, mantiene i caratteri originali.
URL Encode
Converte i caratteri riservati dell'URL (&, =, spazio, cinese, ecc.) nella forma `%XX`. JSON Stringify gestisce solo i caratteri di sintassi JSON; i parametri URL necessitano anche di encodeURIComponent.

Riferimento Escape Caratteri JSON Stringify

Carattere originaleDopo StringifyNomeNota
"\"Apice doppioDeve essere escape altrimenti chiude l'apice esterno
\\\Barra inversaIl carattere di escape stesso necessita doppia rappresentazione
Newline LF\nNewlineLe stringhe multi-linea devono essere escape quando compresse su una riga
Ritorno carrello\rCarriage ReturnCR nei terminatori di riga Windows CRLF
Tabulazione\tTabEscape della tabulazione di indentazione
Backspace\bBackspaceEscape carattere di controllo
Form feed\fForm FeedEscape carattere di controllo
//BarraPermesso ma non richiesto dallo standard JSON

JSON.stringify vs Strumento Stringify vs JSON Escape

StrumentoInputOutputScenario tipico
JSON.stringify()Oggetto JSStringa JSON validaRisposte API, persistenza file, JSON tra servizi
Questo strumento modalità StringifyOggetto JSONStringa incorporabile con apici esterni + escape interniIncorporare in codice, URL, campi stringa DB
Questo strumento modalità ParseStringa stringifiedOggetto JSON standardRipristinare stringhe in log/DB a oggetti
Strumento JSON EscapeStringa sempliceStringa con solo caratteri speciali escapeEscape di caratteri speciali in SQL/HTML/Shell
JSON.stringify(value, replacer, space)Oggetto JS + filtro/indentazione opzionaleStringa JSON indentata/filtrataLog di debug, generare file JSON leggibili

Authoritative References