Welche Funktion hat der Befehl go fmt?

In der Go-Sprache wird der Befehl „go fmt“ hauptsächlich verwendet, um Entwicklern beim Formatieren der von ihnen geschriebenen Codedateien zu helfen. Der Befehl „go fmt“ formatiert den Code aller Go-Sprachquellcodedateien im angegebenen Codepaket gemäß den Go-Sprachcodedateien. Zu allen Go-Sprachquellcodedateien gehören Befehlsquellcodedateien, Bibliotheksquellcodedateien und Testquellcode Dateien. Der Befehl „go fmt“ formatiert nur Quellcodedateien der Go-Sprache, die direkt im Verzeichnis gespeichert sind, das dem angegebenen Codepaket entspricht.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

Einführung in den Befehl go fmt

Für eine Programmiersprache ist die Codeformatierung das umstrittenste Thema. Verschiedene Entwickler können unterschiedliche Codierungsstile und -gewohnheiten haben, aber wenn alle Entwickler dasselbe Format zum Schreiben verwenden können Code können sich Entwickler auf die Probleme konzentrieren, die die Sprache lösen möchte, und so Entwicklungszeit sparen.

Das Go-Sprachentwicklungsteam hat einen einheitlichen offiziellen Codestil formuliert und das gofmt-Tool (gofmt oder go fmt) gestartet, um Entwicklern dabei zu helfen, ihren Code in einen einheitlichen Stil zu formatieren.

gofmt ist ein CLI-Programm, das zuerst die Standardeingabe liest. Wenn ein Dateipfad übergeben wird, werden alle .go-Dateien im Verzeichnis formatiert übergeben, alle .go-Dateien im aktuellen Verzeichnis werden formatiert.

Es gibt auch einen go fmt命令，go fmtBefehl in der Go-Sprache, der eine einfache Kapselung von gofmt ist.

Der Befehl go fmt wird hauptsächlich zum Formatieren der von Ihnen geschriebenen Codedateien verwendet. [Viele Integrationssoftware von Drittanbietern verwendet den Befehl go fmt.]

Verwendung:

go fmt <文件名>.go

Verwenden Sie go fmt Der Befehl wird häufiger mit gofmt verwendet und der Parameter -w ist erforderlich, andernfalls wird das Formatierungsergebnis nicht in die Datei geschrieben. gofmt -w src können Sie das gesamte Projekt formatieren.

Parametereinführung

• -l zeigt die Dateien an, die formatiert werden müssen.

• -w schreibt den umgeschriebenen Inhalt direkt in die Datei, anstatt ihn als Ergebnis auf der Standardausgabe auszugeben.

• -r Fügen Sie eine Umschreiberegel in der Form „a[b:len(a)] -> a[b:]“ hinzu, um die Stapelersetzung zu erleichtern

• -s Vereinfachen Sie den Code in der Datei

• -d zeigt den Unterschied vor und nach der Formatierung an, anstatt in die Datei zu schreiben. Der Standardwert ist falsch.

• -e gibt alle Syntaxfehler in der Standardausgabe aus. Wenn Sie dieses Tag nicht verwenden, werden nur die ersten 10 Fehler in verschiedenen Zeilen gedruckt.

• -cpuprofile unterstützt den Debugging-Modus und schreibt die entsprechende CPU-Datei in den angegebenen Dateibereich

go fmt und gofmt

Der Befehl go fmt formatiert das angegebene Codepaket gemäß der Go-Sprachcodespezifikation Der Code aller Go-Sprachquellcodedateien umfasst Befehlsquellcodedateien, Bibliotheksquellcodedateien und Testquellcodedateien. Beachten Sie, dass die Quellcodedateien der Go-Sprache in den Subcode-Paketen nicht enthalten sind, wenn das Codepaket auch Subcode-Pakete enthält. Mit anderen Worten: Der Befehl go fmt formatiert nur Quellcodedateien der Go-Sprache, die direkt im Verzeichnis gespeichert sind, das dem angegebenen Codepaket entspricht.

Ähnlich wie die Beziehung zwischen den Befehlen go doc und godoc ist der Befehl go fmt eine einfache Kapselung des Befehls gofmt. Der Befehl go fmt selbst kann zwei Tags akzeptieren. Das Flag -n ermöglicht es dem Befehlsprogramm, den intern verwendeten Befehl gofmt und seine Flags und Argumente einfach auszudrucken, ohne ihn tatsächlich auszuführen. Das Flag -x bewirkt, dass das Befehlsprogramm den Befehl sowohl druckt als auch ausführt. Im go fmt-Befehlsprogramm werden die Markierungen -l und -w nach dem aufgerufenen gofmt-Befehl hinzugefügt und die Pfade zu allen Go-Sprachquelldateien im angegebenen Codepaket werden als Parameter verwendet, etwa so:

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

Beachten Sie, dass der Pfad zur Quellcodedatei der Go-Sprache als Parameter des Befehls gofmt relativ und nicht absolut ist. Aber das dient nur dazu, die Parameter kürzer erscheinen zu lassen. Wenn wir den Befehl gofmt direkt ausführen, ist es daher kein Problem, den absoluten Pfad der Quellcodedatei als Parameter zu verwenden. Tatsächlich kann der relative oder absolute Pfad jeder Go-Quellcodedatei oder jedes Verzeichnisses, das Go-Quellcodedateien enthält, als Parameter des Befehls gofmt verwendet werden. Wenn der absolute oder relative Pfad eines Verzeichnisses, das Quellcodedateien der Go-Sprache enthält, als Parameter verwendet wird, verwendet der Befehl gofmt die Quellcodedateien der Go-Sprache in diesem Verzeichnis als Zielquellcodedatei.

Die Markierung, die beim Ausführen des Befehls gofmt im Befehlsprogramm go fmt hinzugefügt wurde, wurde behoben. Wenn wir einen anderen Satz von Tags verwenden möchten, müssen wir den Befehl gofmt direkt verwenden. Schauen wir uns nun alle vom Befehl gofmt akzeptierten Tags an. Wie in der Tabelle unten gezeigt.

Tabelle 0-13 Tag-Beschreibung des gofmt-Befehls

Tag-Name	Tag-Beschreibung
-cpuprofile	Schreiben Sie das CPU-Profil in die angegebene Datei. Als Wert dieses Tags sollte der Pfad zur Datei verwendet werden.
-d	Zeigt den Unterschied (falls vorhanden) vor und nach der Formatierung an, anstatt diese Codes direkt zu formatieren.
-e	Alle Fehler in der Zielquellcodedatei melden. Standardmäßig werden nur die ersten 10 Fehler angezeigt.
-l	Drucken Sie nur die absoluten Pfade von Quellcodedateien aus, die nicht den Formatierungsspezifikationen entsprechen und vom Befehlsprogramm in die Standardausgabe umgeschrieben werden müssen. Anstatt den gesamten neu geschriebenen Inhalt auf der Standardausgabe zu drucken.
-r	Fügen Sie eine Umschreiberegel in der Form „a[b:len(a)] -> a[b:]“ hinzu. Wir müssen es verwenden, wenn wir einige zusätzliche Formatierungsregeln anpassen müssen. Als Wert dieses Tags sollte die Regelzeichenfolge verwendet werden.
-s	Vereinfachen Sie den Code in der Datei.
-w	Schreiben Sie den neu geschriebenen Inhalt direkt in die Datei, anstatt das Ergebnis auf der Standardausgabe zu drucken.

Nachdem wir die Informationen in der obigen Tabelle gelesen haben, können wir das Verhalten des Befehls go fmt leicht verstehen. Weil es den Befehl gofmt intern ausführt und die Flags -l und -w hinzufügt. Dadurch gibt das Befehlsprogramm den absoluten Pfad zu der Datei aus, die in die Standardausgabe umgeschrieben werden muss, und schreibt den formatierten Inhalt direkt in die Originaldatei. Standardmäßig gibt der Befehl gofmt den formatierten Inhalt direkt auf der Standardausgabe aus.

Tatsächlich analysiert das Befehlsprogramm den Inhalt der Zielquellcodedatei in einen abstrakten Syntaxbaum. Wenn während des Analysevorgangs ein Syntaxfehler festgestellt wird, zeigt das Befehlsprogramm eine Fehlermeldung an und wird beendet. Standardmäßig werden nicht alle Syntaxfehler in der Zielquellcodedatei angezeigt. Wir können das Flag -e hinzufügen, um das Befehlsprogramm zu veranlassen, alle Fehler in der Standardausgabe auszugeben.

Benutzerdefinierter Umschreibevorgang

Standardmäßig umfasst der Umschreibevorgang der Quellcodedatei der Go-Sprache durch den Befehl gofmt die folgenden Aspekte:

• Sortieren Sie den Codepaket-Importpfad im abhängigen Paketimportanweisungsblock in lexikographischer Hinsicht Bestellreihenfolge.

• Standardisieren Sie Einrückungen, Leerzeichen und Zeilenumbrüche zwischen einzelnen Sprachen oder Anweisungsblöcken. Konvertieren Sie beispielsweise alle rn in n.

• Kleine Korrekturen an der Code-Syntax. Entfernen Sie beispielsweise redundante Klammern in Switch-Anweisungsblöcken, die zur Bestimmung von Variablentypen verwendet werden.

Wenn Sie zusätzliche Umschreibvorgänge anpassen möchten, müssen Sie das Flag -r verwenden. Der Wert des Flags -r muss „->“ enthalten, z. B. a[b:len(a)] -> Die linke Seite von „->“ sollte ein Beispiel für den Ausdruck sein, der ersetzt werden muss, und die rechte Seite sollte ein Beispiel für den Ausdruck sein, der zum Ersetzen des Ausdrucks auf der linken Seite von „->“ verwendet wird.

Wenn wir das Flag -r verwenden, analysiert das Befehlsprogramm den ersetzten Ausdruck und den Ersatzausdruck in diesem Flagwert in Ausdrucksknoten des abstrakten Syntaxbaums, bevor es die Quellcodedatei analysiert. Wenn die Analyse nicht erfolgreich ist, bedeutet dies, dass nachfolgende Ersetzungsvorgänge nicht durchgeführt werden können und das Befehlsprogramm nach dem Drucken einer Fehlermeldung beendet wird. Wenn die Analyse erfolgreich ist, führt das Befehlsprogramm nach erfolgreicher Analyse der Quellcodedatei den Ausdrucksersetzungsvorgang aus. Das Befehlsprogramm findet den Knoten im abstrakten Syntaxbaum der Quellcodedatei, der dem ersetzten Ausdruck entspricht, und ersetzt ihn durch den Ersatzausdruck. Der Befehl gofmt unterstützt bereits die folgenden benutzerdefinierten Ersetzungsvorgänge, ist jedoch nicht darauf beschränkt:

• Ersetzung von Programmentitätsnamen. Programmentitäten umfassen Variablen, Konstanten, Funktionen, Strukturen und Schnittstellen. Beispiel: -r=array1->array2 und -r=FuncA->FuncB.

• Ersetzung von Programmentitätstypen, einschließlich Ersetzung von Funktionsparametern und Ergebnistypen. Beispiel: -r=string->bool und -r=interface{}->int.

• Entfernung überflüssiger Klammern. Beispiel: Wenn wir die Markierung -r=(x)->x so setzen, wird a = (-x.s) im Zielcode als a = -x.s umgeschrieben und es entsteht auch ((b = - x.f()) im Code )) wird als b = -x.f() umgeschrieben, was auch dazu führt, dass c = -(x).f als c = -x.f umgeschrieben wird, aber d = (&x).s und e = (-x).f werden in () nicht entfernt. Mit anderen Worten: Das Befehlsprogramm entfernt redundante Klammern aus dem Code, ohne die Semantik zu ändern und grammatikalische Mehrdeutigkeiten zu erzeugen.

• Ersatz numerischer Operationen. Beispiel: Wenn wir das Flag -r=x+x->x*2 so setzen, werden alle x + x im Code durch x * 2 ersetzt. Wenn der zu ersetzende Ausdruck außerdem Kommentare enthält, werden diese Kommentare während des Ersetzungsvorgangs entfernt. Beispielsweise wird bei denselben Tag-Einstellungen x /* Der Kommentar */ + x immer noch durch x * 2 ersetzt.

• Ersetzen von Funktionsaufrufen basierend auf der Parameterliste. Beispiel: Wenn wir das Flag -r='funcA(a)->FuncA(a, c)' wie folgt setzen, wird die Anweisung im Zielcode ersetzt, die die Funktion funcA aufruft und eine Variable als Parameter verwendet durch Aufrufen der Funktion FuncA mit einer Anweisung mit der Variablen a und der Variablen c als Parameter. Beachten Sie, dass a als Parameter im ersetzten Ausdruck nur angibt, dass die Funktion funcA einen Parameter hat, und dass es egal ist, wie der Parameter heißt. Das heißt, bei gleichen Flag-Einstellungen wird funcA(b) oder funcA(x) im Zielcode durch FuncA(a, c) ersetzt. Oder wenn wir das Flag -r='funB(x...)->FunC(x)' so setzen, dann funB(x...) oder funB(y...) oder andere ähnliche Aufruffunktionen wird durch FunC(x) ersetzt. Wenn beispielsweise auf einen Parameter vom Typ Array/Slice drei englische Halbbreitenpunkte „…“ folgen, bedeutet dies, dass jedes Element in diesem Parameter als separater Parameter an die Funktion übergeben werden muss. Daher kann diese Ersetzungsmethode verwendet werden, um den Code, der die Funktion aufruft, stapelweise nachzuverfolgen und zu korrigieren, nachdem der Funktionsname und/oder die Parameterliste geändert wurde.

Code-Vereinfachungsvorgang

Wenn wir beim Ausführen des Befehls gofmt das Flag -s hinzufügen, sucht das Befehlsprogramm in der Zielquellcodedatei nach Code, der vereinfacht werden kann, und vereinfacht ihn. Zu den Vereinfachungen gehören:

• Eliminierung unnötiger Typdeklarationen bei der Array-/Slice-Initialisierung.

• Eliminieren Sie unnötige Typdeklarationen bei der Wörterbuchinitialisierung.

• Eliminieren Sie unnötige Indexspezifikationen während Array-/Slice-Slicing-Vorgängen.

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

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

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

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

功能	go fmt命令	gofmt命令
格式化代码	√	√
列出不规范的源码文件	√	√
自动改写源码文件	√	√
显示对比信息	×	√
提示全部错误	×	√
简化代码	×	√
自定义替换/重构辅助	×	√
CPU概要记录	×	√

最后，值得一提的是，当我们执行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视频教程、编程教学】

Das obige ist der detaillierte Inhalt vonWelche Funktion hat der Befehl go fmt?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!