Des lecteurs comme vous aident à soutenir MUO. Lorsque vous effectuez un achat en utilisant des liens sur notre site, nous pouvons gagner une commission d'affiliation. En savoir plus.

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 format package implémente le formatage standard pour le Aller au code source. Le package interagit avec le aller formater outil de ligne de commande 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 :

importer"aller/formater"

Vous pouvez parcourir la documentation de la commande go fmt en spécifiant le aider commande avant le fmt commande:

aller aider 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 le -X drapeau à la commande fmt. L'indicateur -x permet d'écrire les modifications du formateur dans le fichier d'origine.

aller fmt -x main.go

Le -n flag 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 :

aller 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!".

// formatage d'un fichier nommé main.go comme indiqué dans l'exemple ci-dessus 
emballer principal
importer"fmt"
fonctionprincipal() {
var X entier=5
pour je :=0;je fmt. Imprimerln("Bonjour le monde!")
 }
}

Formatage du code source Go

Le package de format contient un Source fonction de formatage des fichiers Go à partir de programmes. Vous devrez lire le fichier et transmettre 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 le LireFichier fonction de la ioutil emballer. La fonction ReadFile prend le nom du fichier et renvoie le contenu du fichier et une erreur de traitement.

fileContent, err := ioutil. LireFichier("main.go")
si erreur != néant {
 enregistrer. Fataln("Une erreur s'est produite lors de la lecture du fichier", euh)
}

Passer le contenu du fichier à la fonction Source renvoie le contenu du fichier formaté et une erreur de traitement.

formaté, euh := format. Source (fichierContenu)
si erreur != néant {
 enregistrer. Fataln("Il y a eu une erreur de formatage avec la fonction source", euh)
}

Vous pouvez écrire le contenu du fichier formaté dans le fichier avec le ÉcrireFichier fonction de la ioutil emballer. La fonction WriteFile prend en compte le nom du fichier, son contenu et mode d'autorisation de fichier, renvoyant toute erreur (s). Le mode d'autorisation n'est pertinent que si le fichier n'existe pas, auquel cas WriteFile le créera.

Le 0644 le mode d'autorisation de fichier 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. EcrireFichier("main.go", formaté, 0644)
si erreur != néant {
 enregistrer. Fataln("Une erreur s'est produite lors de l'écriture du fichier", euh)
}

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 (`):

emballer principal
importer (
"fmt"
"aller/formater"
)


fonctionprincipal() {
// programme simple qui calcule l'aire d'un triangle avec les maths
// fonction 
 formaté, euh := format. Source([]octet(`
emballer principal
importer(
"fmt"
"mathématiques"
)
fonctionprincipal(){
var un float64=3
var b float64=4
var c float64=5
var s float64=(a+b+c)/2
var zone float64=maths. Carré (s*(s-a)*(s-b)*(s-c))
fmt. Imprimerln(« L'aire du triangle est: »,zone)
}
`))
si erreur != néant {
 enregistrer. Fataln("Il y a eu une erreur de formatage avec la fonction source", euh)
 } autre {
 fmt. Imprimerln(chaîne(formaté))
 }
}

Lors du formatage, vous devrez convertir la tranche d'octets en chaîne avec le chaîne fonction. Voici le code source formaté.

Personnalisation du processus de formatage

Vous pouvez personnaliser le processus de formatage avec les Configuration structure. La structure Config contient des champs dans lesquels vous pouvez spécifier des options de format lors de l'instanciation.

importer"aller/formater"
config := &formater. Configuration{
// Tabwidth définit le nombre d'espaces par tabulation.
 Largeur de tabulation: 8,


// UseTabs indique si le formateur doit utiliser des tabulations au lieu de
// les espaces.
 Utilisez les onglets: FAUX,


// TabIndent est utilisé pour déterminer si l'indentation initiale doit être
// fait en utilisant des tabulations ou des espaces.
 TabIndent: vrai,


// NoFinalTab spécifie si un onglet final doit être supprimé de
// lignes avant qu'elles ne soient formatées.
 Pas d'onglet final: vrai,


// Spaces spécifie si les espaces doivent être utilisés pour l'alignement.
 Les espaces: vrai,
// NoTrimTrailingSpace spécifie si l'espace blanc de fin doit
// être coupé des lignes avant qu'elles ne soient formatées.
 NoTrimTrailingSpace: FAUX,
}

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.

fonctionprincipal() {
 fileContent, err := ioutil. LireFichier("main.go")
// notez qu'il s'agit d'une méthode Source de type `config`, et non de la
// `format` package lui-même bien que la fonctionnalité soit la même, vous
// besoin d'adhérer à ceci si vous devez configurer le formateur 
 formaté, euh := config. Source (fichierContenu)


si erreur != néant {
 enregistrer. Fataln("Il y a eu une erreur de formatage avec le type de configuration", euh)
 }
 ioutil. EcrireFichier("main.go", formaté, 0644)
}

Appel de la config. La fonction Source() comme celle-ci formate le contenu du main.go fichier à 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.