Inmatning (.proto-schema)

Utdata (formaterad .proto)

Vad det här verktyget gör

Du klistrar in ett Protocol Buffers-schema med blandad indentering, ihopklämda fältdeklarationer eller slumpmässiga tomrader från en copy-paste, och du vill att det ska se ut som resten av kodbasen. Den här formateraren skriver om filen med två blanksteg per klamernivå, exakt ett blanksteg runt =, ett blanksteg efter , och som mest en sammanhängande tomrad mellan block. Kommentarer — både //-radkommentarer och /* ... */-blockkommentarer — stannar precis där du satte dem.

Den parsar inte och validerar inte schemat, vilket betyder att den fungerar på lätt trasig indata där buf format eller editorns "Format Document" kanske inte gör det. Om din .proto har ett syntaxfel någonstans formateras resten av filen ändå runt det. Avvägningen: den kan inte ordna om fält, normalisera import-ordning eller plocka bort oanvända optioner som en riktig parser-baserad formaterare skulle kunna. För det, kör buf format i din build-pipeline.

Allt körs i din webbläsare — ingen uppladdning, ingen rate limit, inget schema skickas någonstans. Praktiskt när schemat innehåller interna paketnamn, typnamn eller annat som du inte vill skicka till ett tredjeparts-API. Funkar på vilken filstorlek webbläsaren orkar hålla i minnet; även tiotusentals rader formateras på betydligt mindre än en sekund.

Så använder du det

Tre steg. Utdata uppdateras cirka 300 ms efter att du slutat skriva.

Klistra in ditt .proto-schema

Släpp schemat i den vänstra editorn. syntax, package, import-direktiv, message-block, nästlade enum:ar, oneof, map<K, V> — allt hanteras. Blandade radslut (CRLF) normaliseras till LF på vägen ut.

Formateraren ordnar inte om något — fält, importer och optioner stannar i den ordning du skrev dem. Vill du ha kanonisk ordning, kör buf format efteråt.

Läs den formaterade utdatan

Till höger: samma schema, indenterat med 2 blanksteg per {-nivå. Rader som börjar med } dras tillbaka en nivå innan de skrivs ut. Flera tomrader i rad slås ihop till en. Mellanslag i radslut tas bort. Kommentarer bevaras ordagrant inklusive sin relativa position.

Använd resultatet

Kopiera tillbaka till din editor eller ladda ner som formatted.proto. För protoc är utdatan byte-för-byte ekvivalent med indatan — bara whitespace ändras — så du kan släppa tillbaka det utan att oroa dig för wire format eller skillnader i genererad kod. Verifiera genom att köra protoc --descriptor_set_out=before.pb input.proto och samma sak på den formaterade utdatan: descriptors kommer att stämma.

När det faktiskt sparar tid

Städa upp .proto inklistrad från chatt eller dokumentation

En kollega klistrar in ett schemafragment i Slack, indenteringen är förstörd, och du vill ha det i ditt repo. Släpp det här, kopiera den formaterade versionen, klistra in i din fil. Snabbare än "markera allt, retabba"-dansen i editorn.

Standardisera legacy-.proto i ett gammalt repo

Du har ärvt ett Protobuf-repo där varje fil använder olika indentering. Kör varje fil genom den här formateraren, pusha som en enda normaliseringscommit, och slå sedan på buf format i CI för att hålla det så.

Snabbkolla en genererad .proto

Vissa kodgeneratorer (JSON Schema → Protobuf, OpenAPI → Protobuf) spottar ut giltiga men fula scheman. Formatera utdatan, ögna igenom, bestäm om du behåller generatorn eller redigerar för hand.

När du inte kan installera protoc eller buf

Du sitter på en låst maskin, på ett gästnätverk eller bara reviewar en PR i webbläsaren. Den webbläsar-bara formateraren ger dig samma läsbara utdata utan att du behöver installera Protocol Buffers-verktygskedjan.

Vanliga frågor

Skickas mitt schema någonstans?

Nej. Formateraren körs helt i din webbläsare som JavaScript. Inget av schemat — meddelandenamn, paketsökvägar, kommentarer — lämnar din maskin. Öppna DevTools och titta på Network-fliken medan du klistrar in; du kommer att se noll requests.

Bevaras kommentarer?

Ja — både //-radkommentarer och /* ... */-blockkommentarer stannar precis där du satte dem. Kommentarer på egen rad behåller sin relativa position; kommentarer i slutet av en fältrad sitter kvar på det fältet. Den radbaserade ansatsen valdes specifikt så att kommentarer ska överleva intakt.

Hur skiljer sig det här från buf format?

buf format parsar schemat till ett syntaxträd och skriver om det. Det ger starkare garantier — kanonisk option-ordning, konsekvent enum-versalisering osv. — men kräver att schemat parsar rent. Den här formateraren är radbaserad, så den fungerar på lätt trasig indata som buf skulle vägra, och den tvingar inte fram kanonisk ordning. För färdig kod, kör buf format. För scheman mitt i redigering eller fragment från tredje part, använd den här.

Ändrar den schemats semantik?

Nej — bara whitespace ändras. protoc skulle producera samma FileDescriptorProto från både indata och utdata. Du kan verifiera med protoc --descriptor_set_out=before.pb input.proto mot samma sak på den formaterade filen; binär-descriptors är identiska bortsett från eventuella source-info-spanändringar (det är reflection-metadata, inte wire format).

Och indenteringsbredden — kan jag byta från 2 blanksteg?

Utdatan är fast på 2 blanksteg per klamernivå, i linje med konventionen i den officiella Protocol Buffers-stilguiden. Behöver du 4 blanksteg eller tabbar, kör utdatan genom sed eller editorns tab-konvertering. Att hålla formateringens utdata kanonisk slipper konfigurationsdrift mellan team.

Hanterar den CRLF-radslut?

Ja — indata-CRLF (\r\n) normaliseras till LF (\n) på vägen ut. Behöver du CRLF i den sparade filen kommer din editor att koda om vid spara baserat på sin radslutsinställning.

Relaterade verktyg

Om du jobbar med Protobuf-scheman passar de här bra ihop:

Protobuf-formaterare