So formatieren Sie Go Source für saubereren, konsistenten Code
Das Formatieren Ihres Codes ist eine wichtige Möglichkeit, seine Lesbarkeit, Konsistenz und Wiederverwendbarkeit zu verbessern. Korrekt formatierter Code ist einfacher zu verstehen, zu ändern und zu warten.
Eines der großartigen Merkmale von Go sind seine klar definierten Formatierungskonventionen. Sie können das integrierte Formatpaket und den Befehl go fmt verwenden, um Ihren Code automatisch zu formatieren. Dadurch wird sichergestellt, dass andere Go-Programmierer es so einfach wie möglich lesen können.
Das Formatpaket und der fmt-Befehl
Das Formatpaket implementiert die Standardformatierung für den Go-Quellcode. Das Paket interagiert mit dem Go-Format- Befehlszeilentool für Flexibilität bei der Formatierung von Go-Code.
Das Paket format ist ein Untermodul des Pakets go. So können Sie es importieren:
import "go/format"
Sie können die Dokumentation des Befehls go fmt durchsuchen, indem Sie den Befehl help vor dem Befehl fmt angeben :
go help fmt
Geben Sie nach dem fmt-Befehl einen Dateinamen an, um diese Datei zu formatieren. Dadurch werden die Leerzeichen und Einrückungen Ihres Codes an die Go-Standards angepasst.
go fmt main.go
Hinter den Kulissen ist go fmt ein Alias für den Befehl gofmt, insbesondere:
gofmt -l -w
Diese Flags bewirken, dass gofmt alle Änderungen in jede von Ihnen bereitgestellte Datei schreibt und die Namen der geänderten Dateien auflistet.
Sie können das Flag -x zum Befehl fmt hinzufügen . Das Flag -x hilft dabei, Änderungen vom Formatierer in die Originaldatei zu schreiben.
go fmt -x main.go
Das Flag -n funktioniert ähnlich wie -x, nimmt aber keine Änderungen vor. Stattdessen werden die Befehle angezeigt, die go fmt ohne das -n ausführen würde:
go fmt -n main.go
Das Flag weist den Formatierer an, Änderungen anzuzeigen, sodass Sie diese zuerst überprüfen können, bevor Sie sie anwenden.
Hier ist ein einfaches Go-Programm, das Ganzzahlen von null bis fünf durchläuft und die Zeichenfolge „Hello World!“ ausgibt.
// formatting a file named main.go as shown in the example above
package main
import "fmt"
func main() {
var x int=5
for i:=0;i<x;i++{
fmt.Println("Hello World!")
}
}
Go-Quellcode formatieren
Das Formatpaket enthält eine Source – Funktion zum Formatieren von Go-Dateien aus Programmen. Sie müssen die Datei lesen und den Inhalt als Argumente an die Source-Funktion übergeben.
Die Source-Funktion gibt den formatierten Dateiinhalt zurück, den Sie in die Datei oder in eine neue schreiben können.
Sie können Dateien mit der ReadFile- Funktion des ioutil- Pakets lesen. Die ReadFile-Funktion übernimmt den Dateinamen und gibt den Dateiinhalt und einen Fehler zur Behandlung zurück.
fileContent, err: = ioutil.ReadFile("main.go")
if err! = nil {
log.Fatalln("There was an error reading the file", err)
}
Das Übergeben des Dateiinhalts an die Source-Funktion gibt den formatierten Dateiinhalt und einen Verarbeitungsfehler zurück.
formatted, err: = format.Source(fileContent)
if err! = nil {
log.Fatalln("There was a formatting error with the source function", err)
}
Sie können den formatierten Dateiinhalt mit der WriteFile- Funktion des ioutil- Pakets in die Datei schreiben. Die WriteFile-Funktion übernimmt den Dateinamen, den Inhalt und den Dateiberechtigungsmodus und gibt alle Fehler zurück. Der Berechtigungsmodus ist nur relevant, wenn die Datei nicht existiert, in diesem Fall wird WriteFile sie erstellen.
Der 0644 -Dateiberechtigungsmodus bietet:
- Der Dateieigentümer hat Lese- und Schreibberechtigungen.
- Leseberechtigungen für andere Benutzer in derselben Gruppe wie der Eigentümer.
- Keine Berechtigungen für andere Benutzer.
err = ioutil.WriteFile("main.go", formatted, 0644)
if err! = nil {
log.Fatalln("There was an error writing the file", err)
}
Alternativ können Sie den Go-Quellcode zur Formatierung an die Source-Funktion übergeben. Sie können den Code in einem Byte-Slice mit Ticks ( ` ) angeben :
package main
import (
"fmt"
"go/format"
)
func main() {
// simple program that calculates the area of a triangle with the math
// function
formatted, err: = format.Source([]byte(`
package main
import(
"fmt"
"math"
)
func main(){
var a float64=3
var b float64=4
var c float64=5
var s float64=(a+b+c)/2
var area float64=math.Sqrt(s*(s-a)*(s-b)*(s-c))
fmt.Println("The area of the triangle is: ",area)
}
`))
if err! = nil {
log.Fatalln("There was a formatting error with the source function", err)
} else {
fmt.Println(string(formatted))
}
}
Beim Formatieren müssen Sie den Byte-Slice mit der String- Funktion in einen String konvertieren. Hier ist der formatierte Quellcode.
Anpassen des Formatierungsprozesses
Sie können den Formatierungsprozess mit der Struktur Config des Formatpakets anpassen . Die Config-Struktur enthält Felder, in denen Sie Formatoptionen bei der Instanziierung angeben können.
import "go/format"
config: = &format.Config{
// Tabwidth sets the number of spaces per tab.
Tabwidth: 8,
// UseTabs indicates whether the formatter should use tabs instead of
// spaces.
UseTabs: false,
// TabIndent is used to determine if the initial indentation should be
// done using tabs or spaces.
TabIndent: true,
// NoFinalTab specifies whether a final tab should be removed from
// lines before they are formatted.
NoFinalTab: true,
// Spaces specifies whether spaces should be used for alignment.
Spaces: true,
// NoTrimTrailingSpace specifies whether trailing white space should
// be trimmed from lines before they are formatted.
NoTrimTrailingSpace: false,
}
Sie können die Felder verwenden, um das Verhalten Ihres Formatierers anzupassen, indem Sie die Optionen basierend auf Ihren Anforderungen festlegen.
Sie können dann die Source-Methode dieser Struktur verwenden, um einen Byte-Slice basierend auf Ihrer Konfiguration zu formatieren.
func main() {
fileContent, err: = ioutil.ReadFile("main.go")
// note that this is a Source method of the `config` type, not from the
// `format` package itself although the functionality is the same, you'll
// need to adhere to this if you need to configure the formatter
formatted, err: = config.Source(fileContent)
if err! = nil {
log.Fatalln("There was a formatting error with the config type", err)
}
ioutil.WriteFile("main.go", formatted, 0644)
}
Wenn Sie die Funktion config.Source() auf diese Weise aufrufen, wird der Inhalt der Datei main.go mithilfe der Konfigurationsoptionen formatiert. Es gibt den formatierten Inhalt als Byte-Slice und einen Fehler zurück.
Sie können Strings in Go formatieren und manipulieren
Das Formatpaket und der Befehl go fmt können Ihnen dabei helfen, Ihren Codeformatierungsprozess zu automatisieren.
Go bietet auch ein fmt-Paket für die String-Formatierung und ein strings-Paket für die String-Manipulation.
Das fmt-Paket implementiert einfacher formatierte I/O mit Funktionen analog zu den printf- und scanf-Funktionen von C. Die Strings-Funktion implementiert einfache Funktionen zum Bearbeiten von UTF-8-codierten Strings.
Schreibe einen Kommentar