Grundlegende Syntax

Die grundlegende Syntax von Go ist sehr einfach und verständlich. Beginnen wir mit einem einfachsten Beispiel.

package main

import "fmt"

func main() {
   fmt.Println("Hallo Welt!")
}

• Das package-Schlüsselwort deklariert, zu welchem Paket die aktuelle Go-Datei gehört. Eingangsdateien müssen als main-Paket deklariert werden, die Eingangsfunktion ist die main-Funktion. Bei der Benennung benutzerdefinierter Pakete und Funktionen sollte eine Wiederholung vermieden werden.

• import ist das Schlüsselwort zum Importieren, gefolgt vom Namen des zu importierenden Pakets.

• func ist das Schlüsselwort zur Funktionsdeklaration, verwendet um eine Funktion zu deklarieren.

• fmt.Println("Hallo Welt!") ist eine Anweisung, die die Funktion Println aus dem fmt-Paket aufruft, um eine Ausgabe durchzuführen.

Dies ist eine einfache Syntax-Einführung. Im Folgenden werden die Konzepte etwas detaillierter erläutert.

Paket

In Go werden Programme durch Verknüpfung von Paketen erstellt. Die grundlegendste Einheit für den Import in Go ist ein Paket, nicht eine .go-Datei. Ein Paket ist eigentlich ein Ordner (englisch: package). Pakete teilen sich alle Variablen, Konstanten und alle definierten Typen. Der Namensstil von Paketen sollte in Kleinbuchstaben gehalten werden und möglichst kurz sein.

Sichtbarkeit

Wie bereits erwähnt, teilen sich Pakete alle Variablen, Konstanten und definierten Typen. Für externe Pakete gilt dies jedoch nicht. Manchmal möchten Sie nicht, dass andere auf einen bestimmten Typ zugreifen können, daher ist es notwendig, die Sichtbarkeit zu kontrollieren. Sie haben möglicherweise in anderen OOP-Sprachen Schlüsselwörter wie Public, Private gesehen, aber in Go gibt es diese nicht. Die Art und Weise, wie Go die Sichtbarkeit kontrolliert, ist sehr einfach. Die Regeln lauten wie folgt:

• Name beginnt mit einem Großbuchstaben: öffentlicher Typ/Variable/Konstante
• Name beginnt mit einem Kleinbuchstaben oder Unterstrich: privater Typ/Variable/Konstante

Hier ein Beispiel: Die Konstante MyName ist öffentlich, während die Konstante mySalary privat ist.

package example

// Öffentlich
const MyName = "jack"

// Privat
const mySalary = 20_000

Diese Sichtbarkeitsregel gilt überall in der gesamten Go-Sprache.

Import

Importieren Sie ein Paket, um die Typen/Methoden/Funktionen/Variablen dieses Pakets zu verwenden. Die Importsyntax lautet import gefolgt vom Paketnamen:

package main

import "example"

Wenn Sie mehrere Pakete importieren, können Sie dies so schreiben:

package main

import "example"
import "example1"

Oder Sie können sie in Klammern setzen. Diese Methode wird in der Praxis häufiger verwendet.

package main

import (
  "example"
  "example1"
)

Wenn Paketnamen wiederholt werden oder Paketnamen komplex sind, können Sie ihnen Aliase geben:

package main

import (
  e "example"
  e1 "example1"
)

Wenn der Alias ein Unterstrich _ ist, handelt es sich um einen anonymen Import. Ein anonym importiertes Paket kann nicht verwendet werden. Dies wird normalerweise getan, um die init-Funktion unter dem Paket zu laden, aber Sie müssen den Typ im Paket nicht verwenden. Ein häufiges Beispiel ist die Registrierung eines Datenbank-Treibers, aber Sie müssen den Treiber nicht manuell verwenden.

package main

import (
  e "example"
  _ "mysql-driver-go"
)

Wenn Sie nach dem Import auf einen Typ im Paket zugreifen möchten, greifen Sie über Paketname.Identifizierer darauf zu. Im folgenden Beispiel wird der Compiler Ihnen mitteilen, dass auf einen privaten Typ nicht zugegriffen werden kann.

package main

import (
  "example"
   "fmt"
)

func main() {
    fmt.Println(example.MyName)
}

Es gibt eine spezielle Importmethode, bei der alle Typen des Pakets in den aktuellen Paket-Gültigkeitsbereich importiert werden. Bei dieser Importmethode müssen Typen nicht mehr mit dem .-Operator zugegriffen werden. Wenn es jedoch Typen mit demselben Namen gibt, kann die Kompilierung nicht bestanden werden.

package main

import (
  . "example"
)

WARNING

In Go sind zyklische Importe nicht möglich, weder direkt noch indirekt. Wenn beispielsweise Paket A Paket B importiert und Paket B auch Paket A importiert, handelt es sich um einen direkten zyklischen Import. Wenn Paket A Paket C importiert, Paket C Paket B importiert und Paket B wieder Paket A importiert, handelt es sich um einen indirekten zyklischen Import. Bei vorhandenen zyklischen Importen kann die Kompilierung nicht bestanden werden.

Internes Paket

In Go ist vereinbart, dass ein Paket namens internal innerhalb eines Pakets ein internes Paket ist. Externe Pakete können nicht auf Inhalte im internen Paket zugreifen, andernfalls schlägt die Kompilierung fehl. Hier ein Beispiel:

/home/user/go/
    src/
        crash/
            bang/              (go code in package bang)
                b.go
        foo/                   (go code in package foo)
            f.go
            bar/               (go code in package bar)
                x.go
            internal/
                baz/           (go code in package baz)
                    z.go
            quux/              (go code in package main)
                y.go

Aus der Dateistruktur ist ersichtlich, dass das crash-Paket nicht auf Typen im baz-Paket zugreifen kann.

Kommentare

Go unterstützt einzeilige Kommentare und mehrzeilige Kommentare. Es wird empfohlen, ein Leerzeichen zwischen Kommentar und Inhalt einzufügen, zum Beispiel:

// Dies ist das main-Paket
package main

// Importiert das fmt-Paket
import "fmt"

/*
*
Dies ist die Startfunktion main-Funktion
*/
func main() {
  // Dies ist eine Anweisung
  fmt.Println("Hallo Welt!")
}

Identifizierer

Ein Identifizierer ist ein Name, der für die Paketbenennung, Funktionsbenennung, Variablenbenennung usw. verwendet wird. Die Benennungsregeln lauten wie folgt:

• Darf nur aus Buchstaben, Ziffern und Unterstrichen bestehen
• Darf nur mit Buchstaben und Unterstrichen beginnen
• Unterscheidet streng zwischen Groß- und Kleinschreibung
• Darf nicht mit einem vorhandenen Identifizierer wiederholt werden, d. h. muss innerhalb des Pakets eindeutig sein
• Darf nicht mit einem der integrierten Schlüsselwörter von Go in Konflikt stehen

Nachfolgend sind alle integrierten Schlüsselwörter aufgeführt. Weitere Details finden Sie im Referenzhandbuch - Identifizierer:

break        default      func         interface    select
case         defer        go           map          struct
chan         else         goto         package      switch
const        fallthrough  if           range        type
continue     for          import       return       var

Operatoren

Nachfolgend sind die in der Go-Sprache unterstützten Operatoren nach Priorität geordnet. Weitere Details finden Sie im Referenzhandbuch - Operatoren:

Precedence    Operator
    5             *  /  %  <<  >>  &  &^
    4             +  -  |  ^
    3             ==  !=  <  <=  >  >=
    2             &&
    1             ||

Es ist zu beachten, dass Go das ~-Symbol nicht als Negationsoperator verwendet, sondern das ^-Symbol wiederverwendet. Wenn zwei Zahlen ^ verwenden, z. B. a^b, ist es der XOR-Operator. Wenn es nur für eine Zahl verwendet wird, z. B. ^a, ist es der Negationsoperator. Go unterstützt auch erweiterte Zuweisungsoperatoren wie folgt:

a += 1
a /= 2
a &^= 2

TIP

In der Go-Sprache gibt es keine Inkrement- und Dekrement-Operatoren. Sie wurden zu Anweisungen statement herabgestuft und müssen sich hinter dem Operanden befinden. Sie müssen sich also nicht mehr mit Fragen wie i++ und ++i auseinandersetzen.

a++ // Korrekt
++a // Falsch
a-- // Korrekt

Ein weiterer Punkt ist, dass sie keinen Rückgabewert mehr haben, daher sind Anweisungen wie a = b++ falsch.

Literale

Ein Literal ist gemäß der Terminologie der Informatik ein Symbol, das einen festen Wert im Quellcode ausdrückt, auch als Literalwert bezeichnet. Beide Bezeichnungen haben dieselbe Bedeutung: Was geschrieben wird, ist der Wert, der Wert ist der "wörtliche" Wert.

Ganzzahl-Literale

Zur besseren Lesbarkeit ist die Verwendung von Unterstrichen _ zur数字teilung erlaubt, jedoch nur nach dem Vorzeichensymbol und zwischen Ziffern.

24 // 24
024 // 24
2_4 // 24
0_2_4 // 24
10_000 // 10k
100_000 // 100k
0O24 // 20
0b00 // 0
0x00 // 0
0x0_0 // 0

Gleitkomma-Literale

Durch verschiedene Präfixe können Gleitkommazahlen unterschiedlicher Basen ausgedrückt werden:

0.
72.40
072.40       // == 72.40
2.71828
1.e+0
6.67428e-11
1E6
.25
.12345E+5
1_5.         // == 15.0
0.15e+0_2    // == 15.0

0x1p-2       // == 0.25
0x2.p10      // == 2048.0
0x1.Fp+0     // == 1.9375
0X.8p-0      // == 0.5
0X_1FFFP-16  // == 0.1249847412109375
0x15e-2      // == 0x15e - 2 (Ganzzahl-Subtraktion)

Komplexe Literale

0i
0123i         // == 123i
0o123i        // == 0o123 * 1i == 83i
0xabci        // == 0xabc * 1i == 2748i
0.i
2.71828i
1.e+0i
6.67428e-11i
1E6i
.25i
.12345E+5i
0x1p-2i       // == 0x1p-2 * 1i == 0.25i

Zeichen-Literale

Zeichen-Literale müssen in einfache Anführungszeichen '' eingeschlossen werden. Zeichen in Go sind vollständig UTF-8-kompatibel.

'a'
'ä'
'你'
'\t'
'\000'
'\007'
'\377'
'\x07'
'\xff'
'\u12e4'
'\U00101234'

Escape-Zeichen

In Go verfügbare Escape-Zeichen:

\a   U+0007 Glockenzeichen
\b   U+0008 Rücktaste
\f   U+000C Seitenvorschub
\n   U+000A Zeilenvorschub
\r   U+000D Wagenrücklauf
\t   U+0009 Horizontaler Tabulator
\v   U+000B Vertikaler Tabulator
\\   U+005C Umgekehrter Schrägstrich
\'   U+0027 Einfaches Anführungszeichen (nur innerhalb von Zeichen gültig)
\"   U+0022 Doppeltes Anführungszeichen (nur innerhalb von Strings gültig)

String-Literale

String-Literale müssen in doppelte Anführungszeichen "" oder Backticks `` eingeschlossen werden (Backtick-Strings erlauben kein Escaping):

`abc`                // "abc"
`\n
\n`                  // "\\n\n\\n"
"\n"
"\""                 // `"`
"Hello, world!\n"
"今天天气不错"
"日本語"
"\u65e5本\U00008a9e"
"\xff\u00FF"

Funktion

Funktionsdeklarationen in Go werden mit dem Schlüsselwort func durchgeführt, ähnlich wie in den meisten Sprachen:

func main() {
  println(1)
}

Es gibt jedoch zwei Unterschiede in Go-Funktionen. Der erste ist, dass der Parametertyp nachgestellt wird, wie im Folgenden:

func Hello(name string) {
  fmt.Println(name)
}

Der zweite Unterschied ist die Mehrfachrückgabe, und sie können Namen haben:

func Pos() () (x, y float64) {
    ...
}

Stil

In Bezug auf den Codierungsstil erzwingt Go, dass alle denselben Stil verwenden. Die offizielle Go-Stelle bietet ein Formatierungstool gofmt, das über die Befehlszeile verwendet werden kann. Dieses Formatierungstool hat keine Formatierungsparameter, die übergeben werden können. Die einzigen beiden Parameter geben lediglich den Formatierungsprozess aus, sodass keine Anpassung unterstützt wird. Das bedeutet, dass aller durch dieses Tool formatierter Code denselben Code-Stil hat. Dies reduziert die kognitive Belastung für Wartungspersonal erheblich. Daher ist es keine kluge Wahl, in diesem Bereich Individualität anzustreben.

Nachfolgend sind einige Regeln aufgeführt, die Sie beim Schreiben von Code beachten können.

Geschweifte Klammern nach Funktionen

Ob die geschweiften Klammern nach einer Funktion in eine neue Zeile gesetzt werden sollen, ist eine Frage, zu der fast jeder Programmierer seine eigenen Gründe nennen kann. In Go sollten alle geschweiften Klammern nicht in eine neue Zeile gesetzt werden:

// Korrektes Beispiel
func main() {
  fmt.Println("Hallo Welt!")
}

Wenn Sie dies tatsächlich tun, wie im Folgenden:

// Falsches Beispiel
func main()
{
  fmt.Println("Hallo Welt!")
}

Solcher Code kann nicht einmal kompiliert werden, daher erzwingt Go, dass alle Programmierer die Klammern nach Funktionen nicht in eine neue Zeile setzen.

Code-Einrückung

Go verwendet standardmäßig Tab (Tabulator) für Einrückungen, nur in einigen speziellen Fällen werden Leerzeichen verwendet.

Code-Abstand

Die meisten Abstände in Go sind sinnvoll. In gewisser Weise repräsentiert dies auch, wie der Compiler Ihren Code betrachtet. Zum Beispiel die folgende mathematische Operation:

2*9 + 1/3*2

Wie allgemein bekannt ist, hat die Multiplikation eine höhere Priorität als die Addition. Nach der Formatierung ist der Abstand zwischen den *-Symbolen kompakter, was bedeutet, dass sie zuerst berechnet werden, während der Abstand in der Nähe des +-Symbols größer ist, was bedeutet, dass sie später berechnet werden.

Auslassen geschweifter Klammern

In anderen Sprachen können if- und for-Anweisungen normalerweise abgekürzt werden, wie im Folgenden:

for (int i=0; i < 10; i++) printf("%d", i)

In Go ist dies jedoch nicht允许. Sie können nur eine Zeile schreiben, müssen aber geschweifte Klammern hinzufügen:

for i := 0; i < 10; i++ {fmt.Println(i)}

Ternärer Ausdruck

Go hat keinen ternären Ausdruck, daher kann der folgende Code nicht kompiliert werden:

var c = a > b ? a : b

Mit diesem Artikel können Sie ein vorläufiges Verständnis der Go-Syntax erhalten. In den folgenden Inhalten wird dies detaillierter erläutert.