Input (JSON)

Output (schema .proto)

Cosa fa questo strumento

Hai un payload JSON reale — una risposta API di esempio, un body di webhook, una riga di un store NoSQL — e vuoi modellarlo come messaggio Protocol Buffers? Scrivere lo schema a mano è lento e si presta agli errori, soprattutto con oggetti e array annidati. Questo convertitore percorre il JSON, deduce i tipi Protobuf di ogni campo e produce uno schema proto3 pulito che puoi mettere direttamente nel progetto.

L’inferenza dei tipi segue quello che scriveresti tu: string per le stringhe, bool per i booleani, int32 per gli interi che ci stanno in 32 bit, int64 per il resto, double per i numeri non interi, repeated <T> per array con un tipo di elemento uniforme (un messaggio annidato riusato per gli array di oggetti) e blocchi message annidati per gli oggetti annidati. JSON non distingue una struct da una map, quindi tutti gli oggetti escono come messaggi annidati — sostituisci a mano con map<K, V> se i tuoi dati sono davvero una mappa.

I nomi dei campi vengono convertiti da camelCase o kebab-case allo snake_case di convenzione in Protobuf. I numeri di campo sono assegnati 1, 2, 3, … nell’ordine di dichiarazione. L’output è proto3 valido — incollalo in un file .proto, lancia protoc o buf, e hai il codice generato nel linguaggio che preferisci. La conversione gira tutta nel tuo browser — né JSON, né nomi di campo, né valori vengono mandati da nessuna parte.

Come si usa

Tre passi. Funziona con qualsiasi oggetto JSON ben formato — risposte API, voci di log, file di fixture, qualunque cosa.

Incolla il tuo JSON

Metti il JSON nell’editor a sinistra. La radice deve essere un oggetto ({ ... }) — se i tuoi dati partono da un array, prima avvolgilo in un oggetto, p. es. { "items": [...] }. Usa dati realistici: più il campione è rappresentativo, meglio i tipi dedotti corrisponderanno a quello che vuoi sul lungo periodo.

Se il tuo JSON ha chiavi senza virgolette, virgole finali o altre stranezze, fallo passare prima dal JSON Fixer — Protobuf vuole un oggetto pulito da cui partire.

Premi Converti

Clicca il pulsante verde Converti. Il convertitore percorre ogni chiave del JSON, sceglie un tipo Protobuf, costruisce blocchi message annidati per gli oggetti annidati ed emette lo schema con syntax = "proto3"; in cima. I numeri di campo sono assegnati nell’ordine della sorgente.

Usa il .proto

Copia lo schema in un file .proto nel tuo repo. Controlla i tipi dedotti — per i campi dove il campione JSON era vuoto (array vuoto, null) vedrai un commento che segnala che il tipo è stato indovinato. Sistema il necessario, poi lancia protoc o buf generate per produrre codice nel tuo linguaggio.

Quando ti fa davvero risparmiare tempo

Modellare un’API di terze parti come Protobuf

Un fornitore restituisce JSON. Il tuo servizio memorizza Protobuf. Prendi una risposta vera, incollala qui, ottieni uno schema di partenza per il tipo, poi rifinisci. Meglio che leggere la doc e digitare 50 campi a mano.

Migrare un servizio basato su JSON verso gRPC

Stai spostando un microservizio HTTP+JSON su gRPC. Ogni forma di richiesta e risposta serve un .proto. Converti ogni payload catturato in schema Protobuf, mettili in un unico file e hai il contratto abbozzato.

Avviare un modulo Buf

Stai allestendo un nuovo modulo Buf e ti servono schemi realistici per partire? Converti le tue fixture JSON esistenti e usa l’output come seme per i tuoi file .proto — molto più rapido che scriverli da zero.

Scrivere fixture di test per codice Protobuf

Il tuo team ha dati di test in JSON. Il codice nuovo consuma Protobuf. Genera il <code>.proto</code> dal JSON, poi lascia che il codegen costruisca i tipi — fixture e codice restano sincronizzati.

Domande comuni

Il mio JSON viene mandato da qualche parte?

No. Il convertitore gira tutto nel tuo browser come JavaScript. Il tuo JSON — chiavi, valori, qualsiasi cosa sensibile — non lascia mai la tua macchina. Apri DevTools e guarda il tab Network mentre clicchi Converti. Zero richieste.

Come sceglie tra int32, int64 e double?

Per i valori interi controlla se il valore ci sta in un range con segno a 32 bit (-2^31 a 2^31-1). Se sì, int32. Altrimenti int64. I numeri non interi diventano sempre double. Se sai che i tuoi dati sono senza segno o vuoi una larghezza specifica come fixed32, modifica l’output — vedi la tabella dei tipi scalari per tutti i tipi numerici disponibili e i compromessi di codifica sul filo.

Quando un oggetto diventa una map invece di un messaggio annidato?

Sempre un messaggio annidato — mai una map. JSON non distingue una struct da una map, quindi indovinare uno o l’altro sbaglia circa la metà delle volte. Se i tuoi dati sono davvero una mappa chiave-valore (p. es. metadati, header, feature flag), apri l’output e sostituisci a mano message Foo { ... } con map<string, V> foo = N;. La correzione è meccanica e ovvia non appena guardi i dati.

E null e array vuoti?

Entrambi producono un commento nell’output che segnala che il tipo è stato indovinato a partire da un campione degenere. null ricade su string con una nota "nullable". Gli array vuoti ricadono su repeated string con una nota "empty array". Sostituisci quei tipi con quello che ti aspetti davvero.

Perché gli array di tipi misti escono come repeated string?

Protobuf non supporta liste eterogenee in modo diretto. Se il tuo array JSON ha tipi misti (alcune stringhe, alcuni numeri), non c’è un equivalente Protobuf pulito — ti serve google.protobuf.Value, un oneof, oppure rifare la forma dei dati. Il convertitore lo segnala con un commento così decidi tu.

Gestisce JSON molto annidato?

Sì. Ogni oggetto annidato diventa un message annidato con un nome derivato in PascalCase. La profondità di annidamento è limitata solo dalla profondità dello stack, non dal convertitore — anche risposte API molto annidate vengono convertite senza problemi.

Posso fare il giro JSON ↔ Protobuf con questi due strumenti?

Quasi sempre. Da JSON a Protobuf ottieni uno schema; da Protobuf a JSON ottieni un campione. Le forme combaciano sui campi dove il campione JSON aveva un valore rappresentativo. Dove il JSON aveva null o array vuoti, il tipo Protobuf dedotto è una supposizione e il giro completo sarà esatto solo dopo che hai sistemato il tipo.

Strumenti correlati

Se stai armeggiando con JSON e schemi, questi vanno bene insieme:

Convertitore da JSON a Protobuf