Lezers zoals jij steunen MUO. Wanneer u een aankoop doet via links op onze site, kunnen we een aangesloten commissie verdienen. Lees verder.

Het formatteren van uw code is een belangrijke manier om de leesbaarheid, consistentie en herbruikbaarheid te verbeteren. Correct opgemaakte code is gemakkelijker te begrijpen, aan te passen en te onderhouden.

Een van de geweldige functies van Go zijn de goed gedefinieerde opmaakconventies. U kunt het ingebouwde formaatpakket en de opdracht go fmt gebruiken om uw code automatisch te formatteren. Dit helpt ervoor te zorgen dat andere Go-programmeurs het zo gemakkelijk mogelijk kunnen lezen.

Het formaatpakket en het fmt-commando

De formaat pakket implementeert standaardopmaak voor het Ga broncode. Het pakket werkt samen met de ga formaat opdrachtregelprogramma voor flexibiliteit bij het formatteren van Go-code.

Het formaatpakket is een submodule in het go-pakket. Zo kunt u het importeren:

importeren"ga/format"

U kunt door de documentatie van de opdracht go fmt bladeren door de hulp commando voor de fmt commando:

instagram viewer 
ga helpen fmt

Geef een bestandsnaam op na de fmt-opdracht om dat bestand te formatteren. Hiermee worden de witruimte en inspringing van uw code aangepast aan de Go-standaarden.

ga naar main.go

Achter de schermen is go fmt een alias voor het gofmt-commando, met name:

gofmt -l -w

Die vlaggen zorgen ervoor dat gofmt eventuele wijzigingen in elk bestand dat u aanlevert wegschrijft en de namen vermeldt van de bestanden die het wijzigt.

U kunt de -X vlag toe aan het fmt-commando. De vlag -x helpt bij het schrijven van wijzigingen van de formatter naar het originele bestand.

ga fmt -x main.go

De -N vlag werkt op dezelfde manier als -x, maar brengt geen wijzigingen aan. In plaats daarvan worden de opdrachten weergegeven die fmt zou uitvoeren zonder de -n:

ga fmt -n main.go

De vlag vertelt de formatter om wijzigingen weer te geven, zodat u ze eerst kunt bekijken voordat u ze toepast.

Hier is een eenvoudig Go-programma dat gehele getallen van nul tot vijf doorloopt en de tekenreeks "Hello World!" afdrukt.

// formatteren van een bestand met de naam main.go zoals weergegeven in het bovenstaande voorbeeld 
pakket voornaamst
importeren"fmt"
funcvoornaamst() {
var X int=5
voor ik:=0;i fmt. Println("Hallo Wereld!")
 }
}

Go-broncode formatteren

Het formaatpakket bevat een Bron functie voor het formatteren van Go-bestanden van programma's. U moet het bestand lezen en de inhoud als argumenten doorgeven aan de bronfunctie.

De bronfunctie retourneert de geformatteerde bestandsinhoud die u naar het bestand of een nieuw bestand kunt schrijven.

U kunt bestanden lezen met de LeesBestand functie van de ioutil pakket. De functie ReadFile neemt de bestandsnaam op en retourneert de bestandsinhoud en een fout voor verwerking.

fileContent, err := ioutil. LeesBestand("main.go")
als fout!= nihil {
 loggen. dodelijk("Er is een fout opgetreden bij het lezen van het bestand", fout)
}

Als u de bestandsinhoud doorgeeft aan de bronfunctie, wordt de geformatteerde bestandsinhoud en een fout voor de verwerking geretourneerd.

geformatteerd, err := formaat. Bron (fileContent)
als fout!= nihil {
 loggen. dodelijk("Er is een formatteringsfout opgetreden met de bronfunctie", fout)
}

U kunt de geformatteerde bestandsinhoud naar het bestand schrijven met de SchrijfBestand functie van de ioutil pakket. De functie WriteFile neemt de bestandsnaam, inhoud en bestandspermissiemodus, waarbij eventuele fouten worden geretourneerd. De machtigingsmodus is alleen relevant als het bestand niet bestaat, in welk geval WriteFile het zal maken.

De 0644 bestandspermissiemodus geeft:

  • De bestandseigenaar heeft lees- en schrijfrechten.
  • Leesmachtigingen voor andere gebruikers in dezelfde groep als de eigenaar.
  • Geen machtigingen voor andere gebruikers. 
err = ioutil. SchrijfBestand("main.go", geformatteerd, 0644)
als fout!= nihil {
 loggen. dodelijk("Er is een fout opgetreden bij het schrijven van het bestand", fout)
}

Als alternatief kunt u de Go-broncode doorgeven aan de bronfunctie voor opmaak. U kunt de code in een bytesegment specificeren met behulp van vinkjes (`):

pakket voornaamst
importeren (
"fmt"
"ga/format"
)


funcvoornaamst() {
// eenvoudig programma dat de oppervlakte van een driehoek berekent met de wiskunde
// functie 
 geformatteerd, err := formaat. Bron([]byte(`
pakket voornaamst
importeren(
"fmt"
"wiskunde"
)
funcvoornaamst(){
var A vlotter64=3
var B vlotter64=4
var C vlotter64=5
var S vlotter64=(a+b+c)/2
var gebied vlotter64= wiskunde. Sqrt (s*(s-a)*(s-b)*(s-c))
fmt. Println("De oppervlakte van de driehoek is: ",gebied)
}
`))
als fout!= nihil {
 loggen. dodelijk("Er is een formatteringsfout opgetreden met de bronfunctie", fout)
 } anders {
 fmt. Println(snaar(geformatteerd))
 }
}

Bij het formatteren moet u het bytesegment converteren naar een tekenreeks met de snaar functie. Hier is de geformatteerde broncode.

Het formatteringsproces aanpassen

U kunt het opmaakproces aanpassen met de opmaakpakketten configuratie structuur. De Config-structuur bevat velden waarin u formaatopties kunt specificeren bij instantiëring.

importeren"ga/format"
config := &format. Configuratie{
// Tabwidth stelt het aantal spaties per tab in.
 Tabbreedte: 8,


// UseTabs geeft aan of de formatter tabs moet gebruiken in plaats van
// spaties.
 Gebruik Tabs: vals,


// TabIndent wordt gebruikt om te bepalen of de eerste inspringing moet zijn
// gedaan met behulp van tabs of spaties.
 TabIndent: WAAR,


// NoFinalTab geeft aan of een laatste tabblad moet worden verwijderd
// regels voordat ze worden opgemaakt.
 Geen laatste tabblad: WAAR,


// Spaties geeft aan of spaties moeten worden gebruikt voor uitlijning.
 spaties: WAAR,
// NoTrimTrailingSpace geeft aan of witruimte aan het eind moet worden toegevoegd
// worden bijgesneden van regels voordat ze worden opgemaakt.
 NoTrimTrailingSpace: vals,
}

U kunt de velden gebruiken om het gedrag van uw formatter aan te passen door de opties in te stellen op basis van uw vereisten.

U kunt vervolgens de Source-methode van deze struct gebruiken om een ​​byte-segment te formatteren op basis van uw configuratie.

funcvoornaamst() {
 fileContent, err := ioutil. LeesBestand("main.go")
// merk op dat dit een bronmethode is van het type `config`, niet van het
// `format` pakket zelf hoewel de functionaliteit hetzelfde is, zul je
// moet u hieraan houden als u de formatter moet configureren 
 geformatteerd, err := config. Bron (fileContent)


als fout!= nihil {
 loggen. dodelijk("Er is een formatteringsfout opgetreden met het configuratietype", fout)
 }
 ioutil. SchrijfBestand("main.go", geformatteerd, 0644)
}

Het aanroepen van de config. De functie Source() formatteert op deze manier de inhoud van het hoofd.go bestand met behulp van de configuratie-opties. Het retourneert de geformatteerde inhoud als een bytesegment en een fout.

U kunt String in Go formatteren en manipuleren

Het formaatpakket en de opdracht go fmt kunnen u helpen bij het automatiseren van uw codeopmaakproces.

Go biedt ook een fmt-pakket voor het formatteren van strings en een strings-pakket voor het manipuleren van strings.

Het fmt-pakket implementeert eenvoudiger geformatteerde I/O met functies die analoog zijn aan C's printf- en scanf-functies. De strings-functie implementeert eenvoudige functies om UTF-8-gecodeerde strings te manipuleren.