Le formatage de votre code est un moyen important d’améliorer sa lisibilité, sa cohérence et sa réutilisation. Un code correctement formaté est plus facile à comprendre, à modifier et à maintenir.
L’une des grandes caractéristiques de Go est ses conventions de formatage bien définies. Vous pouvez utiliser le paquetage format intégré, et la commande go fmt, pour formater automatiquement votre code. Cela permettra de s’assurer que les autres programmeurs Go pourront le lire aussi facilement que possible.
Le paquetage Format et la commande fmt
Le site format Le paquetage format implémente un formatage standard pour le code source de Go. Ce paquet interagit avec le module format go Outil en ligne de commande pour une plus grande flexibilité dans le formatage du code Go.
Le paquet format est un sous-module du paquet go. Voici comment l’importer :
import "go/format"
Vous pouvez consulter la documentation de la commande go fmt en spécifiant l’attribut help avant la commande fmt commande :
go help fmt Spécifiez un nom de fichier après la commande fmt pour formater ce fichier. Ceci ajustera l’espacement et l’indentation de votre code pour se conformer aux standards Go.
go fmt main.go
Dans les coulisses, go fmt est un alias pour la commande gofmt, plus précisément :
gofmt -l -w Ces drapeaux font en sorte que gofmt écrive tous les changements dans chaque fichier que vous fournissez et liste les noms des fichiers qu’il modifie.
Vous pouvez ajouter l’option -x à la commande fmt. L’option -x aide à écrire les changements du formateur au fichier original.
go fmt -x main.go
Le site -n fonctionne de manière similaire à -x, mais n’apporte pas de modifications. Au lieu de cela, il affiche les commandes que go fmt exécuterait sans le -n :
go fmt -n main.go
L’option indique au formateur d’afficher les changements, ce qui vous permet de les vérifier avant de les appliquer.
Voici un programme Go simple qui passe en boucle les entiers de zéro à cinq et imprime la chaîne « Hello World ».
// 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!")
}
} Formatage du code source Go
Le paquetage de formatage contient un Source Fonction permettant de formater les fichiers Go à partir de programmes. Vous devrez lire le fichier et passer son contenu comme argument à la fonction Source.
La fonction Source retournera le contenu du fichier formaté que vous pourrez écrire dans le fichier ou dans un nouveau fichier.
Vous pouvez lire les fichiers avec la fonction ReadFile fonction de la ioutil paquet. La fonction ReadFile prend le nom du fichier et renvoie le contenu du fichier et une erreur à traiter.
fileContent, err := ioutil.ReadFile("main.go")
if err != nil {
log.Fatalln("There was an error reading the file", err)
}
Le passage du contenu du fichier à la fonction Source renvoie le contenu du fichier formaté et une erreur de traitement.
formatted, err := format.Source(fileContent)
if err != nil {
log.Fatalln("There was a formatting error with the source function", err)
}
Vous pouvez écrire le contenu du fichier formaté dans le fichier avec la fonction WriteFile de la fonction ioutil paquet. La fonction WriteFile prend en compte le nom et le contenu du fichier, ainsi que le mode de permission du fichier, et renvoie les erreurs éventuelles. Le mode de permission n’est pertinent que si le fichier n’existe pas, auquel cas WriteFile le créera.
Le site 0644 le mode de permission du fichier donne :
- Les droits de lecture et d’écriture du propriétaire du fichier.
- Droits de lecture pour les autres utilisateurs du même groupe que le propriétaire.
- Pas de droits pour les autres utilisateurs.
err = ioutil.WriteFile("main.go", formatted, 0644)
if err != nil {
log.Fatalln("There was an error writing the file", err)
}
Alternativement, vous pouvez passer le code source Go à la fonction Source pour le formatage. Vous pouvez spécifier le code dans une tranche d’octets en utilisant des ticks (`) :
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))
}
}
Pour le formatage, vous devrez convertir la tranche d’octets en chaîne de caractères avec la fonction chaîne de caractères fonction. Voici le code source formaté.
Personnalisation du processus de formatage
Vous pouvez personnaliser le processus de formatage à l’aide des options suivantes du paquet de formatage Config struct. La structure Config contient des champs dans lesquels vous pouvez spécifier des options de format lors de l’instanciation.
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,
}
Vous pouvez utiliser ces champs pour personnaliser le comportement de votre formateur en définissant les options en fonction de vos besoins.
Vous pouvez ensuite utiliser la méthode Source de cette structure pour formater une tranche d’octets en fonction de votre configuration.
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)
}
L’appel de la fonction config.Source() de cette manière formate le contenu de la structure main.go en utilisant les options de configuration. Il renvoie le contenu formaté sous forme de tranche d’octets et une erreur.
Vous pouvez formater et manipuler les chaînes de caractères dans Go
Le paquetage format et la commande go fmt peuvent vous aider à automatiser le processus de formatage de votre code.
Go fournit également un paquetage fmt pour le formatage des chaînes de caractères et un paquetage strings pour la manipulation des chaînes de caractères.
Le paquetage fmt implémente des entrées/sorties formatées plus simples avec des fonctions analogues aux fonctions printf et scanf du C. La fonction strings implémente des fonctions simples pour manipuler les chaînes encodées en UTF-8.
