Quelle est la fonction de la commande go fmt

Dans le langage go, la commande "go fmt" est principalement utilisée pour aider les développeurs à formater les fichiers de code qu'ils ont écrits. La commande "go fmt" formatera le code de tous les fichiers de code source du langage Go dans le package de code spécifié conformément aux spécifications du code du langage Go. Tous les fichiers de code source du langage Go incluent les fichiers de code source de commande, les fichiers de code source de bibliothèque et le code source de test. fichiers. La commande "go fmt" formatera uniquement les fichiers de code source du langage Go qui sont directement enregistrés dans le répertoire correspondant au package de code spécifié.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

introduction à la commande go fmt

Pour un langage de programmation, le formatage du code est la question la plus controversée. Différents développeurs peuvent avoir des styles et des habitudes de codage différents, mais si tous les développeurs peuvent utiliser le même format pour écrire du code. , les développeurs peuvent se concentrer sur les problèmes que le langage souhaite résoudre, économisant ainsi du temps de développement.

L'équipe de développement du langage Go a formulé un style de code officiel unifié et lancé l'outil gofmt (gofmt ou go fmt) pour aider les développeurs à formater leur code dans un style unifié.

gofmt est un programme cli qui lira d'abord l'entrée standard. Si un chemin de fichier est transmis, le fichier sera formaté. Si un répertoire est transmis, tous les fichiers .go du répertoire seront formatés. passé, tous les fichiers .go du répertoire actuel seront formatés.

Il existe également une commande go fmt命令，go fmt en langage Go qui est une simple encapsulation de gofmt.

La commande go fmt est principalement utilisée pour vous aider à formater les fichiers de code que vous avez écrits [De nombreux logiciels d'intégration tiers utilisent la commande go fmt]

Utilisation :

go fmt <文件名>.go

Utilisez go fmt Le La commande est plus souvent utilisée avec gofmt et le paramètre -w est requis, sinon le résultat du formatage ne sera pas écrit dans le fichier. gofmt -w src, vous pouvez formater l'intégralité du projet.

Introduction aux paramètres

• -l affiche les fichiers qui doivent être formatés

• -w écrit le contenu réécrit directement dans le fichier au lieu de l'imprimer sur la sortie standard en conséquence.

• -r Ajouter une règle de réécriture sous la forme "a[b:len(a)] -> a[b:]" pour faciliter le remplacement par lots

• -s Simplifier le code dans le fichier

• -d affiche la différence avant et après le formatage au lieu d'écrire dans le fichier. La valeur par défaut est false

• -e imprime toutes les erreurs de syntaxe sur la sortie standard. Si vous n'utilisez pas cette balise, seules les 10 premières erreurs sur différentes lignes seront imprimées.

• -cpuprofile prend en charge le mode débogage et écrit le fichier cpu correspondant dans la portée de fichier spécifiée

go fmt et gofmt

La commande go fmt formatera le package de code spécifié selon les spécifications du code de langue Go Le code de tous les fichiers de code source du langage Go. Tous les fichiers de code source du langage Go incluent les fichiers de code source de commande, les fichiers de code source de bibliothèque et les fichiers de code source de test. Notez que lorsque le package de code contient également des packages de sous-codes, les fichiers de code source du langage Go dans les packages de sous-codes ne sont pas inclus. En d’autres termes, la commande go fmt formatera uniquement les fichiers de code source du langage Go directement enregistrés dans le répertoire correspondant au package de code spécifié.

Semblable à la relation entre la commande go doc et la commande godoc, la commande go fmt est une simple encapsulation de la commande gofmt. La commande go fmt elle-même peut accepter deux balises. L'indicateur -n permet au programme de commande d'imprimer simplement la commande gofmt utilisée en interne ainsi que ses indicateurs et arguments sans réellement l'exécuter. L'indicateur -x amènera le programme de commande à imprimer et à exécuter la commande. Dans le programme de commande go fmt, les marqueurs -l et -w seront ajoutés après la commande gofmt qu'il appelle, et les chemins d'accès à tous les fichiers sources du langage Go dans le package de code spécifié seront utilisés comme paramètres, comme ceci :

hc@ubt:~$ go fmt -n pkgtool
gofmt -l -w golang/goc2p/src/pkgtool/envir.go golang/goc2p/src pkgtoolenvir_test.go golang/goc2p/src/pkgtool/fpath.go golang/goc2p/src/pkgtool ipath.go golang/goc2p/src/pkgtool/pnode.go golang/goc2p/src/pkgtool/util.go golang/goc2p/src/pkgtool/util_test.go

Remarque : le chemin d'accès au fichier de code source du langage Go en tant que paramètre de la commande gofmt est relatif et non absolu. Mais c'est juste pour rendre les paramètres plus courts. Par conséquent, lorsque nous exécutons directement la commande gofmt, il n'y a aucun problème à utiliser le chemin absolu du fichier de code source comme paramètre. En fait, le chemin relatif ou le chemin absolu de tout fichier de code source Go ou répertoire contenant des fichiers de code source du langage Go peut être utilisé comme paramètres de la commande gofmt. Lorsque vous utilisez le chemin absolu ou le chemin relatif d'un répertoire contenant les fichiers de code source du langage Go comme paramètre, la commande gofmt utilisera les fichiers de code source du langage Go dans ce répertoire comme fichier de code source cible.

La marque ajoutée à l'intérieur du programme de commande go fmt lors de l'exécution de la commande gofmt est corrigée. Si nous voulons utiliser un autre ensemble de balises, nous devons utiliser directement la commande gofmt. Jetons maintenant un œil à toutes les balises acceptées par la commande gofmt. Comme le montre le tableau ci-dessous.

Tableau 0-13 Description de la marque de la commande gofmt

Après avoir lu les informations du tableau ci-dessus, nous pouvons facilement comprendre le comportement de la commande go fmt. Parce qu'il exécute la commande gofmt en interne et ajoute les indicateurs -l et -w. Cela amènera le programme de commande à imprimer le chemin absolu du fichier qui doit être réécrit sur la sortie standard et à écrire le contenu formaté directement dans le fichier d'origine. Par défaut, la commande gofmt imprimera le contenu formaté directement sur la sortie standard.

En fait, le programme de commande analysera le contenu du fichier de code source cible dans un arbre de syntaxe abstraite. Lorsqu'une erreur de syntaxe est trouvée pendant le processus d'analyse, le programme de commande affichera un message d'erreur et se terminera. Par défaut, toutes les erreurs de syntaxe dans le fichier de code source cible ne seront pas affichées. Nous pouvons ajouter l'indicateur -e pour que le programme de commande imprime toutes les erreurs sur la sortie standard.

Opération de réécriture personnalisée

Par défaut, l'opération de réécriture du fichier de code source du langage Go par la commande gofmt comprend les aspects suivants :

• Trier le chemin d'importation du package de code dans le bloc d'instruction d'importation du package dépendant en lexicographique Séquence de commande.

• Standardisez l'indentation, les espaces et les sauts de ligne entre des langues individuelles ou des blocs d'instructions. Par exemple, convertissez tous les rn en n.

• Petites corrections à la syntaxe du code. Par exemple, éliminez les parenthèses redondantes dans les blocs d'instructions switch utilisés pour déterminer les types de variables.

Si vous souhaitez personnaliser des opérations de réécriture supplémentaires, vous devez utiliser l'indicateur -r. La valeur de l'indicateur -r doit contenir "->", tel que a[b:len(a)] -> Le côté gauche de "->" doit être un exemple de l'expression qui doit être remplacée, et le côté droit doit être un exemple de l'expression utilisée pour remplacer l'expression du côté gauche de "->".

Si nous utilisons l'indicateur -r, le programme de commande analysera l'expression remplacée et l'expression de remplacement dans cette valeur d'indicateur dans les nœuds d'expression de l'arbre de syntaxe abstraite avant d'analyser le fichier de code source. Si l'analyse échoue, cela signifie que les opérations de remplacement ultérieures ne peuvent pas être effectuées et le programme de commande se terminera après avoir imprimé un message d'erreur. Si l'analyse réussit, le programme de commande effectuera l'opération de remplacement d'expression après avoir analysé avec succès le fichier de code source. Le programme de commande trouvera le nœud dans l'arbre de syntaxe abstraite du fichier de code source qui correspond à l'expression remplacée et le remplacera par l'expression de remplacement. La commande gofmt prend déjà en charge, mais sans s'y limiter, les opérations de remplacement personnalisées suivantes :

• Remplacement des noms d'entités de programme. Les entités de programme incluent des variables, des constantes, des fonctions, des structures et des interfaces. Par exemple : -r=array1->array2 et -r=FuncA->FuncB.

• Remplacement des types d'entités de programme, qui inclut également le remplacement des paramètres de fonction et des types de résultats. Par exemple : -r=string->bool et -r=interface{}->int.

• Suppression des parenthèses redondantes. Par exemple : si nous définissons la marque -r=(x)->x comme ceci, a = (-x.s) dans le code cible sera réécrit comme a = -x.s, et cela fera également ((b = - x.f()) dans le code )) est réécrit comme b = -x.f(), ce qui entraînera également la réécriture de c = -(x).f comme c = -x.f, mais d = (&x).s et e = (-x).f ne sera pas supprimé les parenthèses entre (). En d’autres termes, le programme de commande supprimera les parenthèses redondantes du code sans modifier la sémantique ni créer d’ambiguïté grammaticale.

• Remplacement des opérations numériques. Par exemple : si nous définissons l'indicateur -r=x+x->x*2 comme ceci, tous les x + x dans le code seront remplacés par x * 2. De plus, si l'expression à remplacer contient des commentaires, ces commentaires seront supprimés lors de l'opération de remplacement. Par exemple, avec les mêmes paramètres de balise, x /* Son commentaire */ + x sera toujours remplacé par x * 2.

• Remplacement d'appel de fonction basé sur la liste de paramètres. Par exemple : si nous définissons l'indicateur -r='funcA(a)->FuncA(a, c)' comme ceci, alors l'instruction dans le code cible qui appelle la fonction funcA et prend une variable comme paramètre sera remplacée en appelant la fonction FuncA avec une instruction A avec la variable a et la variable c comme paramètres. Notez que a en tant que paramètre dans l'expression remplacée indique uniquement que la fonction funcA a un paramètre et ne se soucie pas du nom du paramètre. C'est-à-dire qu'avec les mêmes paramètres d'indicateur, funcA(b) ou funcA(x) dans le code cible sera remplacé par FuncA(a, c). Ou, si nous définissons l'indicateur -r='funB(x...)->FunC(x)' comme ceci, alors funB(x...) ou funB(y...) ou d'autres fonctions d'appel similaires sera remplacé par FunC(x). Parmi eux, lorsqu'un paramètre de type array/slice est suivi de trois points anglais demi-largeur "...", cela indique que chaque élément de ce paramètre doit être passé dans la fonction en tant que paramètre distinct. Par conséquent, cette méthode de remplacement peut être utilisée pour effectuer un suivi par lots et corriger le code qui appelle la fonction après la modification du nom de la fonction et/ou de la liste des paramètres.

Opération de simplification du code

Lorsque nous ajoutons le drapeau -s lors de l'exécution de la commande gofmt, le programme de commande recherchera le code qui peut être simplifié dans le fichier de code source cible et le simplifiera. Les simplifications incluent :

• Élimination des déclarations de type inutiles lors de l'initialisation d'un tableau/tranche.

• Éliminez les déclarations de type inutiles lors de l'initialisation du dictionnaire.

• Éliminez les spécifications d'index inutiles lors des opérations de découpage de tableaux/tranches.

• 消除迭代时的非必要临时变量赋值操作。

这些操作基本上都是出于尽量使用Go语言的语法糖已达到减少代码量的目的。我们在编写Go语言代码的时候应该直接使用这些语法糖而不应该依赖使用gofmt命令来简化。这里所说的Go语言的语法糖，我们在第3章中已经有所介绍。

我们在本小节中详细介绍了go fmt命令和gofmt命令。下面我们再汇总一下这两个命令可以为我们做的事情。如下表。

表0-14 go fmt命令和gofmt命令的功能

最后，值得一提的是，当我们执行gofmt命令且没有加任何参数的时候，该命令将会进入到交互模式。在这种模式下，我们可以直接在命令行界面中输入源码，并以Ctrl-d结束。在Linux操作系统下，Ctrl-d代表EOF（End Of File，中文译为文件结束符）。需要注意的是，如果在一行的中间按下Ctrl-d，则表示输出“标准输入”的缓存区，所以这时必须连续按两次Ctrl-d。另外，在Windows操作系统下，Ctrl-z代表EOF，所以需要以Ctrl-z结束。在这之后，gofmt命令会像从源码文件中读取源码那样从命令行界面（也称为标准输入）读取源码，并在格式化后将结果打印到命令行界面（也称为标准输出）中。示例如下：

hc@ubt:~$ gofmt -r='fmt.Println(a)->fmt.Printf("%s\n", a)'
if a=="print" {fmt.Println(a)}                            <----- 在此行的末尾键入回车和Ctrl-d。
warning: rewrite ignored for incomplete programs          <----- 此行及以下就是命令输出的内容。
if a == "print" {
        fmt.Println(a)
}

由上述示例可知，我们可以使用gofmt命令的交互模式格式化任意的代码片段。虽然会显示一行警告信息，但是格式化后的结果仍然会被打印出来。并且，在交互模式下，当我们输入的代码片段不符合Go语言的语法规则时，命令程序也会打印出错误提示信息。在其它方面，命令程序在交互模式与普通模式下的行为也是基本一致的。

【相关推荐：Go视频教程、编程教学】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!