Läsare som du hjälper till att stödja MUO. När du gör ett köp med hjälp av länkar på vår webbplats kan vi tjäna en affiliate-provision. Läs mer.

Att formatera din kod är ett viktigt sätt att förbättra dess läsbarhet, konsekvens och återanvändbarhet. Korrekt formaterad kod är lättare att förstå, ändra och underhålla.

En av Gos fantastiska funktioner är dess väldefinierade formateringskonventioner. Du kan använda det inbyggda formatpaketet och kommandot go fmt för att automatiskt formatera din kod. Detta kommer att hjälpa till att säkerställa att andra Go-programmerare kan läsa den så enkelt som möjligt.

Formatpaketet och kommandot fmt

De formatera paketet implementerar standardformatering för Gå till källkoden. Paketet samverkar med gå format kommandoradsverktyg för flexibilitet vid formatering av Go-kod.

Formatpaketet är en undermodul i go-paketet. Så här importerar du det:

importera"gå/formatera"

Du kan bläddra i dokumentationen för kommandot go fmt genom att ange hjälp kommandot före fmt kommando:

instagram viewer 
gå hjälp fmt

Ange ett filnamn efter kommandot fmt för att formatera filen. Detta kommer att justera kodens blanksteg och indrag för att överensstämma med Go-standarder.

gå fmt main.go

Bakom kulisserna är go fmt ett alias för gofmt-kommandot, specifikt:

gofmt -l -w

Dessa flaggor gör att gofmt skriver eventuella ändringar till varje fil du tillhandahåller och listar namnen på filerna som den ändrar.

Du kan lägga till -x flagga till kommandot fmt. Flaggan -x hjälper till att skriva ändringar från formateraren till originalfilen.

gå fmt -x main.go

De -n flaggan fungerar på samma sätt som -x, men den gör inga ändringar. Istället visar den kommandona som go fmt skulle köras utan -n:

gå fmt -n main.go

Flaggan talar om för formateraren att visa ändringar, vilket gör att du kan granska dem först innan du tillämpar dem.

Här är ett enkelt Go-program som går igenom heltal från noll till fem och skriver ut strängen "Hello World!".

// formatera en fil med namnet main.go som visas i exemplet ovan 
paket huvud
importera"fmt"
funchuvud() {
var x int=5
för jag:=0;i fmt. Println("Hej världen!")
 }
}

Formatera Go Source Code

Formatpaketet innehåller en Källa funktion för att formatera Go-filer från program. Du måste läsa filen och skicka innehållet som argument till källfunktionen.

Källfunktionen returnerar det formaterade filinnehållet som du kan skriva till filen eller ett nytt.

Du kan läsa filer med Läsfil funktion av ioutil paket. ReadFile-funktionen tar in filnamnet och returnerar filinnehållet och ett fel för hantering.

fileContent, err := ioutil. Läsfil("main.go")
om fel!= noll {
 logga. Fatalln("Det uppstod ett fel när filen lästes", fel)
}

Att skicka filinnehållet till funktionen Källa returnerar det formaterade filinnehållet och ett fel för hantering.

formaterad, fel := format. Källa (filinnehåll)
om fel!= noll {
 logga. Fatalln("Det uppstod ett formateringsfel med källfunktionen", fel)
}

Du kan skriva det formaterade filinnehållet till filen med WriteFile funktion av ioutil paket. WriteFile-funktionen tar in filnamnet, innehållet och filbehörighetsläge, returnerar eventuella fel. Behörighetsläget är bara relevant om filen inte finns, i så fall kommer WriteFile att skapa den.

De 0644 filbehörighetsläge ger:

  • Filägaren läs- och skrivbehörigheter.
  • Läsbehörigheter för andra användare i samma grupp som ägaren.
  • Inga behörigheter till andra användare. 
err = ioutil. WriteFile("main.go", formaterad, 0644)
om fel!= noll {
 logga. Fatalln("Det uppstod ett fel när filen skulle skrivas", fel)
}

Alternativt kan du skicka Go-källkoden till Source-funktionen för formatering. Du kan ange koden i ett bytesnitt med bockar (`):

paket huvud
importera (
"fmt"
"gå/formatera"
)


funchuvud() {
// enkelt program som beräknar arean av en triangel med matematiken
// funktion 
 formaterad, fel := format. Källa([]byte(`
paket huvud
importera(
"fmt"
"matematik"
)
funchuvud(){
var a flyta64=3
var b flyta64=4
var c flyta64=5
var s flyta64=(a+b+c)/2
var område flyta64=matte. Sqrt (s*(s-a)*(s-b)*(s-c))
fmt. Println("Triangelns area är:",område)
}
`))
om fel!= noll {
 logga. Fatalln("Det uppstod ett formateringsfel med källfunktionen", fel)
 } annan {
 fmt. Println(sträng(formaterad))
 }
}

Vid formatering måste du konvertera bytesegmentet till sträng med sträng fungera. Här är den formaterade källkoden.

Anpassa formateringsprocessen

Du kan anpassa formateringsprocessen med formatpaketets Konfig struktur. Konfigurationsstrukturen innehåller fält där du kan ange formatalternativ vid instansiering.

importera"gå/formatera"
config := &format. Config{
// Tabwidth anger antalet blanksteg per tabb.
 Tabbredd: 8,


// UseTabs anger om formateraren ska använda tabs istället för
// mellanslag.
 Använd flikar: falsk,


// TabIndent används för att avgöra om den initiala indragen ska vara
// gjort med tabbar eller mellanslag.
 TabIndent: Sann,


// NoFinalTab anger om en sista flik ska tas bort från
// rader innan de formateras.
 NoFinalTab: Sann,


// Mellanslag anger om mellanslag ska användas för justering.
 Mellanslag: Sann,
// NoTrimTrailingSpace anger om efterföljande blanksteg ska
// trimmas från rader innan de formateras.
 NoTrimTrailingSpace: falsk,
}

Du kan använda fälten för att anpassa beteendet hos din formatterare genom att ställa in alternativen baserat på dina krav.

Du kan sedan använda den här strukturens källmetod för att formatera ett bytesegment baserat på din konfiguration.

funchuvud() {
 fileContent, err := ioutil. Läsfil("main.go")
// Observera att detta är en källmetod av typen `config`, inte från
// `format`-paketet i sig även om funktionaliteten är densamma, kommer du
// måste följa detta om du behöver konfigurera formateraren 
 formaterad, err := config. Källa (filinnehåll)


om fel!= noll {
 logga. Fatalln("Det uppstod ett formateringsfel med konfigurationstypen", fel)
 }
 ioutil. WriteFile("main.go", formaterad, 0644)
}

Anropar konfigurationen. Source()-funktionen som denna formaterar innehållet i main.go fil med hjälp av konfigurationsalternativen. Den returnerar det formaterade innehållet som ett bytesegment och ett fel.

Du kan formatera och manipulera strängar i Go

Formatpaketet och kommandot go fmt kan hjälpa dig att automatisera din kodformateringsprocess.

Go tillhandahåller också ett fmt-paket för strängformatering och ett strängpaket för strängmanipulering.

fmt-paketet implementerar enklare formaterad I/O med funktioner analoga med C: s printf- och scanf-funktioner. Stringsfunktionen implementerar enkla funktioner för att manipulera UTF-8-kodade strängar.