Detaillierte Erläuterung der Go-Sprachstruktur

Definition: Es handelt sich um einen aggregierten Datentyp, bei dem es sich um eine aus null oder mehr Werten beliebiger Art aggregierte Entität handelt.

Mitglieder: Jeder Wert wird als Mitglied der Struktur bezeichnet.

Beispiel:

Verwenden Sie einen klassischen Strukturfall, um die Mitarbeiterinformationen des Unternehmens zu verarbeiten. Jede Mitarbeiterinformation enthält eine eindeutige Mitarbeiternummer, den Namen des Mitarbeiters, die Privatadresse, das Geburtsdatum, die berufliche Position und das Gehalt , überlegene Führung usw. Alle diese Informationen müssen an eine Entität gebunden werden, die als ganze Einheit kopiert, als Parameter oder Rückgabewert einer Funktion verwendet oder in einem Array usw. gespeichert werden kann.

Struktur definieren:

type Employee struct {
    ID        int
    Name      string
    Address   string
    DoB       time.Time
    Position  string
    Salary    int
    ManagerID int
}

Variablen definieren:

var dilbert Employee

Zugriffsmitglieder:

dilbert.Salary -= 5000

Mitgliedsadresse abrufen:

position := &dilbert.Position
*position = "Senior " + *position

Punktoperator und Zeiger auf die Struktur:

var employeeOfTheMonth *Employee = &dilbert
employeeOfTheMonth.Position += " (proactive team player)"

Mitgliedsdefinitionsreihenfolge:

Normalerweise entspricht eine Zeile einem Strukturelement, und der Name des Elements steht an erster Stelle und der Typ an letzter Stelle. Wenn die benachbarten Elementtypen jedoch gleich sind, können sie genau wie der Name und in einer Zeile zusammengeführt werden Adressmitglieder unten

type Employee struct {
    ID            int
    Name, Address string
    DoB           time.Time
    Position      string
    Salary        int
    ManagerID     int
}

Regeln für die Benennung von Mitgliedern:

Wenn der Name des Strukturmitglieds mit einem Großbuchstaben beginnt, wird das Mitglied exportiert; dies wird durch die Go-Sprache bestimmt Exportregeln. Eine Struktur kann sowohl exportierte als auch nicht exportierte Elemente enthalten.

Exportbedeutung: Kann in anderen Paketen gelesen und geschrieben werden.

Ein Strukturtyp namens S enthält keine Mitglieder des Typs S: mehr, da der Wert eines Aggregats sich selbst nicht enthalten kann. (Diese Einschränkung gilt auch für Arrays.) Strukturen vom Typ S können jedoch Elemente vom Typ *S-Zeiger enthalten, wodurch wir rekursive Datenstrukturen wie verknüpfte Listen und Baumstrukturen erstellen können.

type tree struct {
    value       int
    left, right *tree
}

Strukturwert:

kann den Wert jedes Mitglieds angeben.

type Point struct{ X, Y int }
p := Point{1, 2}

Das Obige ist die erste Schreibweise, die die Angabe eines Nennwerts für jedes Strukturelement in der Reihenfolge erfordert, in der die Strukturelemente definiert werden. Sie können auch:

anim := gif.GIF{LoopCount: nframes}

mit Mitgliedsnamen und entsprechenden Werten initialisieren, was einige oder alle Mitglieder in dieser Form der Nennwertschreibung umfassen kann; wenn ein Mitglied weggelassen wird, wird es standardmäßig auf den Wert Null gesetzt. Da die Namen der Mitglieder angegeben werden, ist die Reihenfolge, in der alle Mitglieder erscheinen, nicht wichtig.

Hinweis: Zwei verschiedene Schreibformen können nicht gemischt werden.

Struktureinbettung und anonyme Mitglieder:

type Point struct {
    X, Y int
}

type Circle struct {
    Center Point
    Radius int
}

type Wheel struct {
    Circle Circle
    Spokes int
}

Zugriff auf jedes Mitglied:

var w Wheel
w.Circle.Center.X = 8
w.Circle.Center.Y = 8
w.Circle.Radius = 5
w.Spokes = 20

Vereinfachen Sie die Strukturdefinition erneut:

type Circle struct {
    Point
    Radius int
}

type Wheel struct {
    Circle
    Spokes int
}

Wir sind stolz auf die anonyme Einbettungsfunktion kann direkt auf Blattattribute zugreifen, ohne den vollständigen Pfad anzugeben:

var w Wheel
w.X = 8            // equivalent to w.Circle.Point.X = 8
w.Y = 8            // equivalent to w.Circle.Point.Y = 8
w.Radius = 5       // equivalent to w.Circle.Radius = 5
w.Spokes = 20

Das Strukturliteral muss der Struktur folgen, wenn der Formtyp deklariert wird, daher können nur die folgenden beiden Syntaxen verwendet werden, sie schließen sich gegenseitig aus und sind äquivalent:

w = Wheel{Circle{Point{8, 8}, 5}, 20}

w = Wheel{
    Circle: Circle{
        Point:  Point{X: 8, Y: 8},
        Radius: 5,
    },
    Spokes: 20, // NOTE: trailing comma necessary here (and at Radius)
}

Struktur-Tag:

In der Strukturdeklaration ist der String-Nennwert nach den Jahres- und Farbelementen das Strukturelement Tag

type Movie struct {
    Title  string
    Year   int  `json:"released"`
    Color  bool `json:"color,omitempty"`
    Actors []string
}

var movies = []Movie{
    {Title: "Casablanca", Year: 1942, Color: false,
        Actors: []string{"Humphrey Bogart", "Ingrid Bergman"}},
    {Title: "Cool Hand Luke", Year: 1967, Color: true,
        Actors: []string{"Paul Newman"}},
    {Title: "Bullitt", Year: 1968, Color: true,
        Actors: []string{"Steve McQueen", "Jacqueline Bisset"}},
    // ...
}

wie folgt: Die Datenstruktur von JSON ist Besonders geeignet für das JSON-Format und die Konvertierung zwischen beiden ist einfach. Der Prozess der Konvertierung eines Slices, einer Struktur, die Filmen in der Go-Sprache ähnelt, in JSON wird als Marshalling bezeichnet. Das Marshalling erfolgt durch Aufrufen der json.Marshal-Funktion:

data, err := json.Marshal(movies)
if err != nil {
    log.Fatalf("JSON marshaling failed: %s", err)
}
fmt.Printf("%s\n", data)

Die Marshal-Funktion gibt ein codiertes Byte-Slice zurück, das eine lange Zeichenfolge ohne Leerzeicheneinrückung enthält; wir packen es zur Anzeige ein:

[{"Title":"Casablanca","released":1942,"Actors":["Humphrey Bogart","Ingr
id Bergman"]},{"Title":"Cool Hand Luke","released":1967,"color":true,"Ac
tors":["Paul Newman"]},{"Title":"Bullitt","released":1968,"color":true,"
Actors":["Steve McQueen","Jacqueline Bisset"]}]

Darunter: Das Year-Element wurde codiert und freigegeben, und das Color-Element wurde codiert und wurde beginnend mit einem Kleinbuchstaben in Farbe umgewandelt. Dies wird durch das Konformationsmitglied-Tag verursacht. Ein Struktur-Member-Tag ist eine Zeichenfolge von Metainformationen, die dem Member während der Kompilierungsphase zugeordnet werden:

Year  int  `json:"released"`
Color bool `json:"color,omitempty"`

Das Member-Tag einer Struktur kann ein beliebiges String-Literal sein, besteht jedoch normalerweise aus einer Reihe von durch Leerzeichen getrennten Schlüsseln. :„Wert“-Sequenz von Schlüssel-Wert-Paaren; da der Wert doppelte Anführungszeichen enthält, werden Mitglieds-Tags im Allgemeinen in Form nativer Zeichenfolgenliterale geschrieben.

Weitere Informationen zu Go Language finden Sie in der Spalte Go Language Tutorial.

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Go-Sprachstruktur. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!