Comment formater Go Source pour un code cohérent plus propre
Le formatage de votre code est un moyen important d’améliorer sa lisibilité, sa cohérence et sa réutilisabilité. 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 package de format intégré et la commande go fmt pour formater automatiquement votre code. Cela aidera à garantir que les autres programmeurs Go puissent le lire aussi facilement que possible.
Le package de format et la commande fmt
Le package de format implémente le formatage standard pour le code source Go. Le package interagit avec l’ outil de ligne de commande de format go pour plus de flexibilité dans le formatage du code Go.
Le package format est un sous-module du package go. Voici comment vous pouvez l’importer :
import "go/format"
Vous pouvez parcourir la documentation de la commande go fmt en spécifiant la commande help avant la commande fmt :
go help fmt
Spécifiez un nom de fichier après la commande fmt pour formater ce fichier. Cela ajustera les espaces blancs et l’indentation de votre code pour se conformer aux normes 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 amènent gofmt à écrire toutes les modifications apportées à chaque fichier que vous fournissez et à répertorier les noms des fichiers qu’il modifie.
Vous pouvez ajouter l’ indicateur -x à la commande fmt. L’indicateur -x permet d’écrire les modifications du formateur dans le fichier d’origine.
go fmt -x main.go
Le drapeau -n fonctionne de la même manière que -x, mais il 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’indicateur indique au formateur d’afficher les modifications, ce qui vous permet de les examiner avant de les appliquer.
Voici un programme Go simple qui parcourt des nombres 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 package de format contient une fonction Source pour formater les fichiers Go à partir de programmes. Vous devrez lire le fichier et passer le contenu en tant qu’arguments à la fonction Source.
La fonction Source renverra le contenu du fichier formaté que vous pouvez écrire dans le fichier ou dans un nouveau.
Vous pouvez lire des fichiers avec la fonction ReadFile du package ioutil . La fonction ReadFile prend le nom du fichier et renvoie le contenu du fichier et une erreur de traitement.
fileContent, err: = ioutil.ReadFile("main.go")
if err! = nil {
log.Fatalln("There was an error reading the file", err)
}
Passer le 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 du package ioutil . La fonction WriteFile prend en compte le nom du fichier, le contenu et le mode d’autorisation du fichier, renvoyant toute erreur. Le mode d’autorisation n’est pertinent que si le fichier n’existe pas, auquel cas WriteFile le créera.
Le mode d’autorisation de fichier 0644 donne :
- Le propriétaire du fichier a les autorisations de lecture et d’écriture.
- Lire les autorisations accordées aux autres utilisateurs du même groupe que le propriétaire.
- Aucune autorisation pour les autres utilisateurs.
err = ioutil.WriteFile("main.go", formatted, 0644)
if err! = nil {
log.Fatalln("There was an error writing the file", err)
}
Vous pouvez également transmettre le code source Go à la fonction Source pour le formatage. Vous pouvez spécifier le code dans une tranche d’octet à l’aide de 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))
}
}
Lors du formatage, vous devrez convertir la tranche d’octets en chaîne avec la fonction de chaîne . Voici le code source formaté.
Personnalisation du processus de formatage
Vous pouvez personnaliser le processus de formatage avec la structure Config du package de format . 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 les 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 du fichier main.go à l’aide des options de configuration. Il renvoie le contenu formaté sous la forme d’une tranche d’octet et d’une erreur.
Vous pouvez formater et manipuler une chaîne dans Go
Le package de format et la commande go fmt peuvent vous aider à automatiser votre processus de formatage de code.
Go fournit également un package fmt pour le formatage des chaînes et un package strings pour la manipulation des chaînes.
Le package fmt implémente des E/S formatées plus simples avec des fonctions analogues aux fonctions printf et scanf de C. La fonction strings implémente des fonctions simples pour manipuler les chaînes encodées en UTF-8.
Laisser un commentaire