Skip to content

Convertitore JSON in YAML

Incolla JSON e ottieni YAML istantaneamente nel browser. Conversione live, K8s e Compose, rientro 2/4 spazi, virgolette Norway-safe. 100% privato.

Niente tracciamento Funziona nel browser Gratuito
Opzioni · 2 spazi · auto · block
Rientro
Stile
0 caratteri
YAML Output
0 righe
Revisionato per la conformità a RFC 8259, l'output secondo le specifiche YAML 1.2 e la correttezza della gestione del problema Norway — Go Tools Engineering Team · May 4, 2026

Cos'è YAML e perché convertire da JSON?

YAML (YAML Ain't Markup Language) è un formato di serializzazione dati leggibile dall'uomo, progettato per file di configurazione, infrastruttura-come-codice e ovunque un umano scriva dati che una macchina leggerà. La sua sintassi basata sull'indentazione non richiede parentesi graffe o quadre, rendendola molto più leggibile di JSON per strutture nidificate complesse. Kubernetes, Helm, Ansible, Docker Compose, GitHub Actions, CircleCI e praticamente tutti gli strumenti cloud-native usano YAML come formato di configurazione principale. Convertire JSON in YAML è quindi uno dei compiti più comuni nel DevOps e nello sviluppo backend — ricevi una definizione di risorsa da un'API in JSON e hai bisogno di un manifest YAML da committare nel controllo versione.

Questo strumento ha quattro differenziatori importanti rispetto ai tipici convertitori online:

**1. Problema Norway — Virgolette Automatiche Sicure.** Il rischio maggiore nella conversione da JSON a YAML è il problema Norway di YAML. In YAML 1.1 (usato ancora da milioni di parser in produzione, inclusi vecchi Kubernetes, PyYAML, Ansible e Psych di Ruby), le stringhe semplici yes, no, on, off, y e n vengono interpretate come valori booleani true/false. Questo ha colpito in modo famoso il codice ISO del paese Norvegia ("NO" → false) e ha causato veri blocchi di produzione nelle configurazioni Kubernetes. YAML 1.2 ha corretto il problema, ma i tuoi parser potrebbero non essere su 1.2. La modalità Auto di virgolette predefinita di questo strumento usa la libreria eemeli/yaml con lo schema YAML 1.1, così racchiude automaticamente tra virgolette qualsiasi stringa problematica per Norway, garantendo conversioni sicure sia con i parser YAML 1.1 che 1.2. Per saperne di più, leggi il nostro articolo complementare su Il problema Norway di YAML e le differenze JSON-YAML.

**2. Preservazione dell'ordine delle chiavi.** A differenza di alcuni convertitori che ordinano le chiavi alfabeticamente, questo strumento preserva l'ordine di inserimento originale delle chiavi del JSON — corrispondendo al comportamento di JSON.parse() in tutti i moderni motori JavaScript. Questo è importante per i manifest Kubernetes (dove apiVersion e kind sono attesi per primi per convenzione), le specifiche OpenAPI (dove info appare prima di paths) e qualsiasi configurazione in cui l'ordinamento dei campi è significativo per leggibilità o diff.

**3. Avviso sulla perdita di precisione dei numeri grandi.** I numeri JSON maggiori di 2^53 - 1 (9007199254740991) non possono essere rappresentati esattamente nel float a doppia precisione IEEE 754 di JavaScript. Quando JSON.parse() legge un intero grande come un campo resourceVersion di Kubernetes (che è un intero a 64 bit sul server), lo tronca silenziosamente. Questa è una limitazione fondamentale di JavaScript nel browser che riguarda tutti gli strumenti JSON basati su browser, incluso questo. La soluzione sicura è assicurarsi che i grandi interi siano memorizzati come stringhe nel JSON prima della conversione. Questo strumento documenta onestamente questo comportamento nell'errore comune «Perdita di precisione numerica» qui sotto.

**4. Privacy 100% basata su browser.** I tuoi dati JSON — che spesso contengono chiavi API, credenziali di database, configurazioni di servizi interni e segreti di produzione — non lasciano mai il browser. Nessun dato viene inviato a nessun server. Puoi verificarlo nella scheda Rete del browser. Questo è l'unico modo sicuro per gestire dati di configurazione sensibili in uno strumento online. Per la direzione inversa, vedi il nostro strumento complementare su Convertitore YAML in JSON, e il nostro Formattatore JSON se hai bisogno di validare e formattare il JSON prima di convertirlo.

La natura leggibile dall'uomo di YAML comporta un compromesso: ha più casi limite di analisi rispetto a JSON. Oltre al problema Norway, YAML ha stranezze con i numeri ottali (0777 viene interpretato come 511 in YAML 1.1), la sintassi per stringhe multi-riga (| per letterale, > per ripiegato), riferimenti con ancore e alias (&anchor e *alias) e supporto per più documenti (separatore ---). JSON non ha nessuna di queste complessità — è un formato rigoroso e minimale con solo sei tipi di dati. Per lo scambio di dati tra macchine, JSON è quasi sempre la scelta migliore. Per file di configurazione modificati dagli umani dove la leggibilità e i commenti contano, YAML vince. Questo convertitore ti dà il meglio di entrambi: usa JSON a livello programmatico, converti in YAML per la tua infrastruttura.

// Convert JSON to YAML in Node.js using the eemeli/yaml library
import { Document } from 'yaml';

const data = JSON.parse('{"apiVersion":"apps/v1","kind":"Deployment"}');

// version: '1.1' ensures Norway-problem strings (yes/no/on/off/y/n)
// are automatically quoted in the output for YAML 1.1 parser safety
const doc = new Document(data, { version: '1.1' });

const yamlString = doc.toString({
  indent: 2,
  lineWidth: 0,         // disable line wrapping
  defaultStringType: 'PLAIN',   // Auto mode: only quote when needed
});

console.log(yamlString);
// apiVersion: apps/v1
// kind: Deployment

Funzionalità Principali

Conversione in tempo reale

L'output YAML si aggiorna istantaneamente mentre digiti o incolli JSON — nessun pulsante Converti necessario. Gli input grandi (>200 KB) passano automaticamente alla modalità manuale per mantenere il browser reattivo.

Rientro a 2 o 4 spazi

Passa tra 2 spazi (standard per Kubernetes, Docker Compose e GitHub Actions) e 4 spazi (convenzione Ansible). I tab sono vietati in YAML — questo strumento usa sempre spazi.

Virgolette automatiche sicure (Norway-safe)

La modalità Auto predefinita usa lo schema YAML 1.1 per mettere automaticamente tra virgolette stringhe come "no", "yes", "on", "off", "y" e "n" che verrebbero lette erroneamente come booleani dai parser YAML 1.1, prevenendo configurazioni di produzione errate.

Stili Block e Flow

Lo stile Block produce YAML leggibile con indentazione, ideale per manifest e file di configurazione. Lo stile Flow produce YAML compatto in stile inline simile al JSON — utile per snippet di documentazione o strumenti che preferiscono output minimale.

Privacy 100% basata su browser

Tutta la conversione gira localmente nel browser usando JavaScript. I tuoi dati JSON — incluse chiavi API, credenziali e configurazioni di produzione — non vengono mai inviati a nessun server, mai registrati e mai archiviati.

Supporta file K8s, Compose e Terraform

Ottimizzato per casi d'uso DevOps reali: manifest Kubernetes, stack Docker Compose, values di Helm chart, workflow GitHub Actions, specifiche OpenAPI e output di piani Terraform JSON — con esempi per ciascuno.

Esempi

Kubernetes Deployment

{"apiVersion":"apps/v1","kind":"Deployment","metadata":{"name":"my-app","namespace":"production","labels":{"app":"my-app","version":"1.0.0"}},"spec":{"replicas":3,"selector":{"matchLabels":{"app":"my-app"}},"template":{"metadata":{"labels":{"app":"my-app"}},"spec":{"containers":[{"name":"my-app","image":"my-app:1.0.0","ports":[{"containerPort":8080}],"resources":{"requests":{"memory":"64Mi","cpu":"250m"},"limits":{"memory":"128Mi","cpu":"500m"}}}]}}}}

Converti un manifest Kubernetes Deployment dal formato di risposta API JSON in YAML per applicarlo con kubectl apply -f

Docker Compose

{"version":"3.9","services":{"web":{"image":"nginx:1.25-alpine","ports":["80:80","443:443"],"environment":{"NGINX_HOST":"example.com","NGINX_PORT":"80"},"depends_on":["db"],"restart":"unless-stopped"},"db":{"image":"postgres:16-alpine","environment":{"POSTGRES_DB":"mydb","POSTGRES_USER":"admin","POSTGRES_PASSWORD":"secret"},"volumes":["pgdata:/var/lib/postgresql/data"]}},"volumes":{"pgdata":{}}}

Converti una definizione di servizio Docker Compose da JSON al formato YAML richiesto da docker compose up

GitHub Actions Workflow

{"name":"CI","on":{"push":{"branches":["main"]},"pull_request":{"branches":["main"]}},"jobs":{"build":{"runs-on":"ubuntu-latest","steps":[{"uses":"actions/checkout@v4"},{"name":"Set up Node.js","uses":"actions/setup-node@v4","with":{"node-version":"20","cache":"pnpm"}},{"name":"Install dependencies","run":"pnpm install --frozen-lockfile"},{"name":"Run tests","run":"pnpm test"}]}}}

Converti la definizione di un workflow CI GitHub Actions da JSON in YAML per aggiungerlo alla cartella .github/workflows/

OpenAPI Spec

{"openapi":"3.0.3","info":{"title":"User API","version":"1.0.0","description":"Manage application users"},"paths":{"/users":{"get":{"summary":"List users","operationId":"listUsers","parameters":[{"name":"limit","in":"query","schema":{"type":"integer","default":20}}],"responses":{"200":{"description":"Success","content":{"application/json":{"schema":{"type":"array","items":{"$ref":"#/components/schemas/User"}}}}}}}},"/users/{id}":{"get":{"summary":"Get user","operationId":"getUser","parameters":[{"name":"id","in":"path","required":true,"schema":{"type":"string"}}],"responses":{"200":{"description":"Success"}}}}},"components":{"schemas":{"User":{"type":"object","properties":{"id":{"type":"string"},"name":{"type":"string"},"email":{"type":"string","format":"email"}}}}}}

Converti una specifica OpenAPI 3.0 da JSON in YAML — il formato preferito da Swagger UI, Redoc e dalla maggior parte degli strumenti API

package.json

{"name":"my-app","version":"1.0.0","description":"A sample Node.js application","private":true,"scripts":{"dev":"vite","build":"tsc && vite build","preview":"vite preview","test":"vitest","lint":"eslint . --ext .ts,.tsx"},"dependencies":{"react":"^18.3.0","react-dom":"^18.3.0"},"devDependencies":{"typescript":"^5.4.0","vite":"^5.2.0","vitest":"^1.5.0","eslint":"^8.57.0","@types/react":"^18.3.0"},"engines":{"node":">=20.0.0","pnpm":">=9.0.0"}}

Converti un tipico package.json Node.js in YAML — utile per migrare la configurazione di progetto verso strumenti che preferiscono YAML

Terraform JSON Plan

{"format_version":"1.0","terraform_version":"1.7.4","variables":{"region":{"value":"us-east-1"}},"planned_values":{"root_module":{"resources":[{"address":"aws_s3_bucket.main","mode":"managed","type":"aws_s3_bucket","name":"main","values":{"bucket":"my-app-assets","force_destroy":false,"tags":{"Environment":"production","ManagedBy":"terraform"}}}]}},"resource_changes":[{"address":"aws_s3_bucket.main","mode":"managed","type":"aws_s3_bucket","name":"main","change":{"actions":["create"],"before":null,"after":{"bucket":"my-app-assets","force_destroy":false}}}]}

Converti l'output di un piano Terraform JSON in YAML per la revisione umana, le audit trail GitOps e le pipeline CI/CD — una funzionalità che la maggior parte dei convertitori non offre

Come Usarlo

  1. 1

    Incolla il tuo JSON

    Inserisci o incolla i tuoi dati JSON nel campo di input qui sopra. Puoi anche cliccare su «Carica esempio» per provare un campione come un Kubernetes Deployment, un file Docker Compose o un piano Terraform.

  2. 2

    Vedi l'output YAML in tempo reale

    Il YAML compare istantaneamente nel pannello di output. Regola le Opzioni (rientro 2/4, virgolette Auto/Doppio/Singolo, stile Block/Flow) per soddisfare i requisiti dello strumento di destinazione.

  3. 3

    Copia o scarica

    Clicca Copia per copiare il YAML negli appunti, o Scarica per salvarlo come file .yaml pronto per kubectl apply, docker compose up o qualsiasi altro strumento.

Errori Comuni di Conversione

Virgole finali

JSON non consente una virgola dopo l'ultimo elemento di un oggetto o array. Questo è estremamente comune quando si copia da codice JavaScript, che permette le virgole finali. Rimuovi la virgola finale prima di convertire.

✗ Errato 
{"name": "Alice", "role": "admin",}
✓ Corretto 
{"name": "Alice", "role": "admin"}

Virgolette singole

JSON richiede virgolette doppie per tutti i valori stringa e le chiavi degli oggetti. Le virgolette singole sono valide in JavaScript e Python, ma sono un errore di sintassi in JSON.

✗ Errato 
{'name': 'Alice', 'active': true}
✓ Corretto 
{"name": "Alice", "active": true}

Chiavi senza virgolette

Tutte le chiavi degli oggetti JSON devono essere racchiuse tra virgolette doppie. Le chiavi senza virgolette sono valide nei letterali oggetto JavaScript ma causano un errore di analisi nel JSON rigoroso.

✗ Errato 
{name: "Alice", role: "admin"}
✓ Corretto 
{"name": "Alice", "role": "admin"}

Commenti non consentiti

Il JSON standard non supporta commenti di alcun tipo — né //, né /* */, né #. Se hai bisogno di commenti nella configurazione, usa YAML (che supporta commenti #) o JSONC (JSON with Comments, usato da VS Code). Rimuovi tutti i commenti prima di usare i dati come JSON.

✗ Errato 
{"port": 8080 // HTTP port}
✓ Corretto 
{"port": 8080}

Problema Norway di YAML (gestito automaticamente in modalità Auto)

Nei parser YAML 1.1 (usati da Kubernetes, Ansible, PyYAML, Ruby Psych), le stringhe semplici yes, no, on, off, y e n vengono interpretate come booleani true/false invece che come stringhe. La modalità Auto di questo strumento mette automaticamente tra virgolette questi valori nell'output YAML per garantire conversioni sicure con qualsiasi parser YAML 1.1 o 1.2. Se selezioni la modalità Doppio o Singolo, tutte le stringhe vengono messe esplicitamente tra virgolette, il che evita anch'esso il problema — ma la modalità Auto produce l'output più naturale.

✗ Errato 
# JSON input: {"country": "no", "enabled": "yes"}
# YAML without quoting (dangerous):
country: no
enabled: yes
# YAML 1.1 parser reads: country=false, enabled=true
✓ Corretto 
# YAML with Auto quoting (safe):
country: 'no'
enabled: 'yes'
# YAML 1.1 parser reads: country="no", enabled="yes"

Perdita di precisione per interi grandi

JavaScript può rappresentare gli interi esattamente solo fino a 2^53 - 1 (9007199254740991). Gli interi JSON più grandi di questo — come i campi resourceVersion di Kubernetes (che sono int64 sul server) — vengono arrotondati silenziosamente quando analizzati da JSON.parse(). Questo numero troncato compare poi nell'output YAML. Questa è una limitazione fondamentale di JavaScript nel browser che riguarda tutti gli strumenti JSON basati su browser. La soluzione sicura è memorizzare i grandi interi come stringhe nel JSON prima di convertire.

✗ Errato 
// JSON input (resourceVersion is int64 on K8s server)
{"resourceVersion": 9007199254740993}
// JavaScript reads it as: 9007199254740992 (precision lost)
// YAML output will contain the wrong number
✓ Corretto 
// Store large integers as strings to preserve precision
{"resourceVersion": "9007199254740993"}
// YAML output: resourceVersion: '9007199254740993' (exact)

Casi d'Uso Comuni

Manifest Kubernetes
Converti le risposte API JSON da kubectl get -o json o l'API Kubernetes in manifest YAML per workflow GitOps, overlay Kustomize e deployment con kubectl apply -f.
File Docker Compose
Trasforma l'output JSON di docker inspect o le configurazioni di servizi generate programmaticamente in file docker-compose.yaml compatibili con docker compose up e i deployment Docker Stack.
Values di Helm Chart
Converti gli export di configurazione JSON in file values YAML per i deployment di Helm chart, abilitando la configurazione dell'infrastruttura sotto controllo versione con una sintassi YAML pulita.
Workflow GitHub Actions
Costruisci le definizioni di workflow GitHub Actions programmaticamente in JSON e convertile nel formato .github/workflows/*.yaml richiesto dal runner GitHub Actions.
Specifiche OpenAPI
Converti le specifiche OpenAPI/Swagger dal formato JSON restituito da molti framework (FastAPI, SpringDoc) al formato YAML preferito da Swagger UI, Redoc e gli strumenti API gateway.
Migrazione della configurazione
Migra la configurazione dell'applicazione memorizzata in JSON (appsettings.json, config.json) al formato YAML per strumenti che richiedono o preferiscono YAML, aggiungendo la possibilità di usare commenti per la documentazione.

Dettagli Tecnici

Analisi JSON conforme a RFC 8259
L'input JSON viene analizzato usando il JSON.parse() nativo del browser, pienamente conforme a RFC 8259. Fornisce messaggi di errore di sintassi accurati incluse informazioni di posizione (numero di riga e colonna al meglio) e gestisce tutti i tipi di dati JSON: stringhe, numeri, booleani, null, array e oggetti.
Output YAML 1.2 tramite Document API di eemeli/yaml con schema YAML 1.1
Il YAML viene generato usando la libreria eemeli/yaml (v2.8+, CVE-safe) tramite la sua Document API con version: '1.1'. Questa combinazione produce output conforme a YAML 1.2 applicando le regole di virgolettatura YAML 1.1 — le stringhe problematiche per Norway (yes/no/on/off/y/n) vengono automaticamente messe tra virgolette nell'output, rendendolo sicuro sia per i parser YAML 1.1 che 1.2. Il line wrapping è disabilitato (lineWidth: 0) per preservare le stringhe lunghe intatte.
100% basato su browser — nessun upload, nessun server
Tutta l'elaborazione avviene interamente nel motore JavaScript del browser. Nessun dato viene trasmesso in rete in nessun momento. Gli input più grandi di 200 KB passano automaticamente dalla modalità in tempo reale alla modalità manuale (richiedendo un clic esplicito su Converti) per mantenere il browser reattivo e prevenire il blocco del thread principale durante la serializzazione pesante.

Buone Pratiche

Usa sempre la modalità Auto per le configurazioni DevOps
Quando converti JSON per Kubernetes, Helm, Ansible, Docker Compose o GitHub Actions, usa sempre la modalità Auto (Norway-safe) predefinita. I parser YAML 1.1 in questi strumenti interpreteranno silenziosamente bare yes, no, on, off, y e n come booleani — la modalità Auto lo previene in modo trasparente.
Usa 2 spazi di rientro per gli strumenti cloud-native
Kubernetes, Docker Compose, GitHub Actions e Helm usano tutti 2 spazi di indentazione per convenzione. Usare 4 spazi in questi file è YAML valido ma creerà inconsistenze con gli esempi della comunità, le configurazioni generate automaticamente e i manifest esistenti del tuo team.
Memorizza i grandi interi come stringhe prima di convertire
I campi resourceVersion, uid e altri campi int64 di Kubernetes dall'API server possono superare il range degli interi sicuri di JavaScript (2^53 - 1). Se hai bisogno di precisione numerica esatta, memorizza questi valori come stringhe JSON prima di convertire. Questo è particolarmente importante per l'output di kubectl get -o json che include campi generati lato server.
Valida prima il JSON
Se la tua sorgente JSON è scritta a mano o proviene da un sistema che occasionalmente produce output non valido (virgole finali, chiavi senza virgolette, commenti), validala con un formattatore JSON prima di convertire. Usa il nostro Formattatore JSON per trovare e correggere prima gli errori di sintassi, poi converti il JSON pulito in YAML.
Preferisci lo stile Block per i file che vanno nel controllo versione
Il YAML in stile Block produce diff puliti e leggibili in Git perché ogni campo appare sulla propria riga. Lo stile Flow (compatto, inline) rende i diff più difficili da leggere e rivedere. Riserva lo stile Flow per incorporare brevi snippet YAML nella documentazione o per strumenti che richiedono output compatto.

Domande Frequenti

Come converto JSON in YAML online?
Incolla il tuo JSON nel campo di input qui sopra. Lo strumento lo converte in YAML istantaneamente nel browser — nessun clic necessario. Puoi regolare l'indentazione (2 o 4 spazi), lo stile delle virgolette (Auto, Doppio o Singolo) e lo stile di output (Block o Flow) dal pannello Opzioni. Quando il YAML compare nell'area di output, clicca Copia per copiarlo negli appunti o Scarica per salvarlo come file .yaml. Tutto gira localmente — i tuoi dati non lasciano mai il dispositivo.
Cos'è il problema Norway di YAML e come lo gestisce questo strumento?
Il problema Norway di YAML si riferisce a una stranezza della specifica YAML 1.1 per cui stringhe semplici come "no", "yes", "on", "off", "y" e "n" vengono interpretate come valori booleani (false/true) invece che come stringhe. Ciò ha causato un famoso problema reale: il codice ISO del paese Norvegia ("NO") veniva letto come il booleano false in playbook Ansible e configurazioni Kubernetes. In YAML 1.2 il problema è stato corretto, ma milioni di parser in produzione (versioni precedenti di Kubernetes, PyYAML, Ansible, Psych di Ruby) usano ancora YAML 1.1. La modalità Auto di questo strumento (quella predefinita) aggiunge automaticamente le virgolette a tutte le stringhe problematiche per Norway, garantendo conversioni sicure sia con i parser YAML 1.1 che 1.2. Quando vengono rilevate stringhe problematiche per Norway nell'input, un banner di avviso elenca esattamente i valori che sono stati messi automaticamente tra virgolette.
Perché il problema Norway è importante per Kubernetes e il DevOps?
I manifest YAML di Kubernetes, i values di Helm, i playbook Ansible e i workflow GitHub Actions vengono tutti analizzati da strumenti che storicamente usavano YAML 1.1. Se hai una chiave di configurazione con il valore "no" (ad esempio un codice paese, un flag abilitato come stringa o un campo booleano personalizzato), un parser YAML 1.1 lo convertirà silenziosamente nel booleano false. Questo può causare configurazioni di servizio errate, estremamente difficili da debuggare perché il YAML appare corretto come testo ma si comporta diversamente una volta analizzato. Usa sempre la modalità Auto quando converti JSON per Kubernetes o qualsiasi toolchain DevOps.
Devo usare 2 o 4 spazi di indentazione per YAML?
Usa 2 spazi per i manifest Kubernetes, i values Helm, i file Docker Compose e i workflow GitHub Actions — questi strumenti sono progettati attorno ai 2 spazi YAML ed è la convenzione della comunità. Usa 4 spazi per i playbook Ansible (che seguono una convenzione a 4 spazi) e quando il tuo team o la tua organizzazione ha una guida di stile che lo richiede. YAML proibisce completamente i tab — tutta l'indentazione deve essere a spazi. Lo strumento usa 2 spazi come impostazione predefinita, la scelta corretta per la grande maggioranza dei casi d'uso cloud-native.
Come uso questo strumento per creare un manifest Kubernetes?
Se hai una definizione di risorsa Kubernetes in JSON (da kubectl get deployment my-app -o json, da una risposta API o da un blocco risorsa Terraform), incollala nel campo di input. Seleziona 2 spazi di indentazione (predefinito) e virgolette Auto (predefinito, che gestisce il problema Norway). L'output YAML è immediatamente pronto per kubectl apply -f. Puoi anche cliccare Scarica per salvare il file con estensione .yaml e passarlo direttamente a kubectl apply -f -. L'esempio K8s Deployment qui sopra mostra un manifest di deployment completo che puoi caricare e modificare.
Come converto un JSON Docker Compose in YAML?
Incolla il tuo JSON Docker Compose nel campo di input. Usa 2 spazi di indentazione (convenzione Docker Compose) e stile Block. Il YAML di output è compatibile con docker compose up, docker compose config e Docker Stack. Uno scenario comune è esportare la configurazione di uno stack in esecuzione con docker inspect e poi convertirla in un file compose.yaml. L'esempio Docker Compose qui sopra include definizioni di servizi con porte, variabili d'ambiente, volumi e depends_on.
I numeri JSON maggiori di 2^53 perdono precisione durante la conversione in YAML?
Sì. Questa è una limitazione fondamentale di JavaScript: il tipo Number di JavaScript usa il float a doppia precisione IEEE 754, che può rappresentare gli interi esattamente solo fino a 2^53 - 1 (9007199254740991). Qualsiasi intero oltre quel limite — come i campi resourceVersion di Kubernetes (che sono int64 sul server) — viene arrotondato silenziosamente quando viene analizzato da JSON.parse(). Ad esempio, il valore 9007199254740993 diventa 9007199254740992 in JavaScript, e questo numero troncato apparirà nell'output YAML. Questo problema riguarda tutti gli strumenti JSON basati su browser, non solo questo. La soluzione sicura è memorizzare i grandi interi come stringhe nel JSON ("resourceVersion": "9007199254740993") — appariranno come stringhe YAML senza perdita di precisione.
Il convertitore preserva l'ordine originale delle chiavi del JSON?
Sì. La libreria eemeli/yaml usata da questo strumento preserva l'ordine di inserimento, che corrisponde al comportamento di JSON.parse() in tutti i moderni motori JavaScript (V8, SpiderMonkey, JavaScriptCore). Le chiavi compaiono nell'output YAML nello stesso ordine in cui apparivano nell'input JSON. Questo è importante per i manifest Kubernetes e le specifiche OpenAPI, dove l'ordine dei campi è spesso significativo per la leggibilità e i diff.
Quando usare JSON invece di YAML?
Usa JSON quando: stai costruendo API e servizi web (JSON è il formato universale di scambio dati), quando la velocità di analisi automatica conta, quando hai bisogno di strict type safety, o quando il consumatore è un'applicazione JavaScript/TypeScript. Usa YAML quando: scrivi file di configurazione destinati alla modifica umana (manifest Kubernetes, pipeline CI/CD, playbook Ansible, values Helm), quando vuoi commenti nella tua configurazione, o quando la leggibilità è più importante della rigidità. Una regola utile: se una macchina lo scrive o lo legge per prima, usa JSON; se un umano lo scrive e una macchina lo legge, usa YAML.
Come posso convertire JSON in YAML dalla riga di comando?
L'approccio più diffuso è combinare yq e jq. Installa yq (la versione di Mike Farah, non quella Python): brew install yq su macOS o wget https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 -O /usr/local/bin/yq per Linux. Poi esegui: cat input.json | yq -P per l'output formattato come YAML. In alternativa: yq -o yaml input.json oppure cat input.json | python3 -c "import sys, json, yaml; yaml.dump(json.load(sys.stdin), sys.stdout, default_flow_style=False)". Per Kubernetes: kubectl get deployment my-app -o yaml converte direttamente dall'API del cluster.
Come converto JSON in YAML in Python, Node.js o Go?
In Python: import json, yaml; yaml.dump(json.load(open('input.json')), open('output.yaml', 'w'), default_flow_style=False) usando PyYAML, oppure ruamel.yaml per la fedeltà di andata e ritorno. In Node.js: import { Document } from 'yaml'; const doc = new Document(JSON.parse(input), { version: '1.1' }); const result = doc.toString({ indent: 2, lineWidth: 0 }) — questa è la stessa libreria e lo stesso approccio usati da questo strumento. In Go: import gopkg.in/yaml.v3; json.Unmarshal(jsonBytes, &data); yaml.Marshal(data) — nota che Go YAML v3 usa YAML 1.1 di default, quindi le stringhe problematiche per Norway vengono messe automaticamente tra virgolette.
I miei dati JSON vengono inviati a un server quando uso questo strumento?
No. Tutta la conversione avviene interamente nel browser usando JavaScript. I tuoi dati JSON non vengono mai trasmessi in rete, mai archiviati su alcun server e mai registrati o analizzati. Questo rende lo strumento sicuro da usare con chiavi API, credenziali di database, file di configurazione interni, manifest Kubernetes in produzione e qualsiasi altro dato sensibile. Lo strumento non usa cookie per i tuoi dati di input e nessuna analisi di terze parti che potrebbe catturare ciò che incolli. Puoi verificarlo aprendo la scheda Rete del browser — vedrai zero richieste attivate dall'incollaggio del JSON.
Esiste un limite di dimensione per l'input JSON?
Non c'è un limite rigido, ma gli input grandi (oltre 200 KB) passano automaticamente dalla conversione in tempo reale alla modalità manuale. In modalità manuale, compare un pulsante Converti e la conversione viene eseguita solo quando lo clicchi — questo evita che il thread principale del browser si blocchi per 200-500 ms a ogni battitura. Per file JSON molto grandi (multi-megabyte), considera strumenti da riga di comando come yq o jq per prestazioni migliori. Lo strumento gestisce in modo efficiente i payload reali tipici come export di namespace Kubernetes completi, grandi specifiche OpenAPI e file Docker Compose multi-servizio.

Strumenti correlati

Vedi tutti gli strumenti →

Decodificatore e codificatore Base64

Codifica e formattazione

Decodifica e codifica Base64 online gratis. Conversione in tempo reale con pieno supporto UTF-8 ed emoji. 100% privato — gira nel tuo browser. Nessuna registrazione.

Formattatore e Validatore JSON

Codifica e formattazione

Formatta, valida e abbellisci JSON direttamente nel browser. Strumento online gratuito con controllo sintassi, rilevamento errori, minifica e copia in un clic. 100% privato.

Codificatore e Decodificatore URL con Parser URL Integrato

Codifica e formattazione

Decodifica o codifica URL in tempo reale con parser URL integrato. Doppia modalità: encodeURI e encodeURIComponent. 100% privato, nessun dato inviato a server online.

Convertitore YAML in JSON

Codifica e formattazione

Incolla YAML e ottieni JSON istantaneamente nel browser. Supporta manifest K8s, specifiche OpenAPI e values Helm. 100% privato, nessun upload, nessun server.

Convertitore di Basi Numeriche — Bin, Hex, Ott, Dec

Strumenti di conversione

Converti istantaneamente tra binario, esadecimale, decimale, ottale e qualsiasi base (2-36). Strumento online gratuito e privato: tutta l'elaborazione avviene nel tuo browser.

Comprimi Immagini Online — JPEG, PNG e WebP

Strumenti di conversione

Comprimi JPEG, PNG e WebP fino all'80% in meno — nel tuo browser, senza upload. Batch di 20 immagini, regola la qualità, confronta prima e dopo. Gratuito e privato.