Tiefes Eintauchen in das Go Type System

German (Deutsch) translation by Alex Grigorovich (you can also view the original English article)

Go hat ein sehr interessantes Typensystem. Es verzichtet auf Klassen und Vererbung von Schnittstellen und Kompositionen, hat nicht nur Vorlagen oder Generika. Einzigartig ist auch der Umgang mit Sammlungen.

In diesem Tutorial erfahren Sie mehr über die Vor- und Nachteile des Go-Typsystems und wie Sie es effektiv zum Schreiben von klarem und idiomatischem Go-Code verwenden können.

Das Gesamtbild des Go Type Systems

Das Go-Typ-System unterstützt die prozeduralen, objektorientierten und funktionalen Paradigmen. Die generische Programmierung wird nur sehr eingeschränkt unterstützt. Go ist zwar eine ausgesprochen statische Sprache, bietet jedoch über Schnittstellen, erstklassige Funktionen und Reflexion genügend Flexibilität für dynamische Techniken. Dem Typsystem von Go fehlen Funktionen, die in den meisten modernen Sprachen üblich sind:

Es gibt keinen Ausnahmetyp, da die Fehlerbehandlung von Go auf Rückkehrcodes und der Fehlerschnittstelle basiert.
Es gibt keine Überlastung des Bedieners.
Es gibt keine Funktionsüberladung (gleicher Funktionsname mit unterschiedlichen Parametern).
Es gibt keine optionalen oder Standardfunktionsparameter.

Diese Auslassungen sind alle beabsichtigt, um Go so einfach wie möglich zu gestalten.

Geben Sie Aliase ein

Sie können in Go Alias-Typen erstellen und unterschiedliche Typen erstellen. Sie können einem Alias-Typ ohne Konvertierung keinen Wert des zugrunde liegenden Typs zuweisen. Beispielsweise verursacht die Zuweisung var b int = a im folgenden Programm einen Kompilierungsfehler, da der Typ Age ein Alias von int ist, aber kein int:

package main


type Age int

func main() {
    var a Age = 5
    var b int = a
}


Output:

tmp/sandbox547268737/main.go:8: cannot use a (type Age) as
type int in assignment

Sie können Typdeklarationen gruppieren oder eine Deklaration pro Zeile verwenden:

type IntIntMap map[int]int
StringSlice []string

type (
    Size   uint64
    Text  string
    CoolFunc func(a int, b bool)(int, error)
)

Grundtypen

Alle üblichen Verdächtigen sind hier: Bool, String, Ganzzahlen und Ganzzahlen ohne Vorzeichen mit expliziten Bitgrößen, Gleitkommazahlen (32-Bit und 64-Bit) und komplexen Zahlen (64-Bit und 128-Bit).

bool
string
int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr
byte // alias for uint8
rune // alias for int32, represents a Unicode code point
float32 float64
complex64 complex128

Strings

Strings in Go sind UTF8-codiert und können daher jedes Unicode-Zeichen darstellen. Das Zeichenfolgenpaket bietet eine Reihe von Zeichenfolgenoperationen. Hier ist ein Beispiel dafür, wie Sie eine Reihe von Wörtern in Groß- und Kleinschreibung umwandeln und zu einem Satz zusammenfügen.

package main

import (
    "fmt"
    "strings"
)

func main() {
    words := []string{"i", "LikE", "the ColORS:", "RED,", 
                      "bLuE,", "AnD", "GrEEn"}
    properCase := []string{}
    
    for i, w := range words {
        if i == 0 {
            properCase = append(properCase, strings.Title(w))
        } else {
            properCase = append(properCase, strings.ToLower(w))
        }
    }
    
    sentence := strings.Join(properCase, " ") + "."
    fmt.Println(sentence)
}

Pointers

Go hat Zeiger. Der Nullzeiger (siehe Zero Value später) ist Null. Sie können mit dem Operator & einen Zeiger auf einen Wert abrufen und mit dem Operator * zurückkehren. Sie können auch Zeiger auf Zeiger haben.

package main

import (
    "fmt"
)


type S struct {
    a float64
    b string
}

func main() {
    x := 5
    px := &x
    *px = 6
    fmt.Println(x)
    ppx := &px
    **ppx = 7
    fmt.Println(x)
}

Objekt orientierte Programmierung

Go unterstützt die objektorientierte Programmierung über Schnittstellen und Strukturen. Es gibt keine Klassen und keine Klassenhierarchie, obwohl Sie anonyme Strukturen in Strukturen einbetten können, die eine Art Einzelvererbung bereitstellen.

Eine ausführliche Beschreibung der objektorientierten Programmierung in Go finden Sie unter Let's Go: Objektorientierte Programmierung in Golang.

Schnittstellen

Schnittstellen sind der Eckpfeiler des Go-Systems. Eine Schnittstelle ist nur eine Sammlung von Methodensignaturen. Jeder Typ, der alle Methoden implementiert, ist mit der Schnittstelle kompatibel. Hier ist ein kurzes Beispiel. Die Shape-Oberfläche definiert zwei Methoden: GetPerimeter() und GetArea(). Das Square-Objekt implementiert die Schnittstelle.

type Shape interface {
    GetPerimeter() uint
    GetArea() uint
}

type Square struct {
   side  uint
}

func (s *Square) GetPerimeter() uint {
    return s.side * 4
}

func (s *Square) GetArea() uint {
    return s.side * s.side
}

Die leere Schnittstelle interface{} ist mit jedem Typ kompatibel, da keine Methoden erforderlich sind. Die leere Schnittstelle kann dann auf ein beliebiges Objekt verweisen (ähnlich wie Javas Object- oder C/C ++ - Void-Zeiger) und wird häufig für die dynamische Typisierung verwendet. Schnittstellen sind immer Zeiger und zeigen immer auf ein konkretes Objekt.

Einen vollständigen Artikel zu Go-Schnittstellen finden Sie unter Definieren und Implementieren einer Go-Schnittstelle.

Strukturen

Strukturen sind die benutzerdefinierten Typen von Go. Eine Struktur enthält benannte Felder, bei denen es sich um Basistypen, Zeigertypen oder andere Strukturtypen handeln kann. Sie können Strukturen auch anonym in andere Strukturen als Form der Implementierungsvererbung einbetten.

Im folgenden Beispiel sind die S1- und S2-Strukturen in die S3-Struktur eingebettet, die auch ein eigenes int-Feld und einen Zeiger auf einen eigenen Typ hat:

package main

import (
    "fmt"
)


type S1 struct {
    f1 int
}

type S2 struct {
    f2 int
}

type S3 struct {
    S1
    S2
    f3 int
    f4 *S3
}


func main() {
    s := &S3{S1{5}, S2{6}, 7, nil}
    
    fmt.Println(s)
}

Output:

&{{5} {6} 7 <nil>}

Typ Assertions

Mit Zusicherungen-Typ können Sie eine Schnittstelle in ihren konkreten Typ konvertieren. Wenn Sie den zugrunde liegenden Typ bereits kennen, können Sie ihn einfach bestätigen. Wenn Sie sich nicht sicher sind, können Sie mehrere Zusicherungen ausprobieren, bis Sie den richtigen Typ gefunden haben.

Im folgenden Beispiel gibt es eine Liste von Dingen, die Zeichenfolgen und Nicht-Zeichenfolgenwerte enthalten, die als Teil leerer Schnittstellen dargestellt werden. Der Code durchläuft alle Dinge und versucht, jedes Element in eine Zeichenfolge zu konvertieren und alle Zeichenfolgen in einem separaten Slice zu speichern, das schließlich gedruckt wird.

package main

import "fmt"

func main() {
    things := []interface{}{"hi", 5, 3.8, "there", nil, "!"}
    strings := []string{}
    
    for _, t := range things {
        s, ok := t.(string)
        if ok {
            strings = append(strings, s)
        }
    }
    
    fmt.Println(strings)
    
}

Output:

[hi there !]

Reflexion

Mit dem Go reflect-Paket können Sie den Typ einer Schnittstelle ohne Typzusicherungen direkt überprüfen. Sie können den Wert einer Schnittstelle auch extrahieren und auf Wunsch in eine Schnittstelle konvertieren (nicht so nützlich).

Hier ist ein ähnliches Beispiel wie im vorherigen Beispiel, aber anstatt die Zeichenfolgen zu drucken, werden sie nur gezählt, sodass keine Konvertierung von Schnittstelle {} in Zeichenfolge erforderlich ist. Der Schlüssel ruft refle.Type() auf, um ein Typobjekt abzurufen, das über eine Kind() -Methode verfügt, mit der wir erkennen können, ob es sich um eine Zeichenfolge handelt oder nicht.

package main

import (
    "fmt"
    "reflect"
)


func main() {
    things := []interface{}{"hi", 5, 3.8, "there", nil, "!"}
    stringCount := 0
    
    for _, t := range things {
        tt := reflect.TypeOf(t)
        if tt != nil && tt.Kind() == reflect.String {
            stringCount++
        }
    }
    
    fmt.Println("String count:", stringCount)
}

Funktionen

Funktionen sind erstklassige Bürger in Go. Das heißt, Sie können Variablen Funktionen zuweisen, Funktionen als Argumente an andere Funktionen übergeben oder als Ergebnisse zurückgeben. Dadurch können Sie den funktionalen Programmierstil mit Go verwenden.

Das folgende Beispiel zeigt einige Funktionen, GetUnaryOp() und GetBinaryOp(), die anonyme Funktionen zurückgeben, die zufällig ausgewählt wurden. Das Hauptprogramm entscheidet anhand der Anzahl der Argumente, ob es eine unäre oder eine binäre Operation benötigt. Es speichert die ausgewählte Funktion in einer lokalen Variablen namens "op" und ruft sie dann mit der richtigen Anzahl von Argumenten auf.

package main

import (
    "fmt"
    "math/rand"
)

type UnaryOp func(a int) int
type BinaryOp func(a, b int) int


func GetBinaryOp() BinaryOp {
    if rand.Intn(2) == 0 {
        return func(a, b int) int { return a + b }
    } else {
        return func(a, b int) int { return a - b }
    }
}

func GetUnaryOp() UnaryOp {
    if rand.Intn(2) == 0 {
        return func(a int) int { return -a }
    } else {
        return func(a int) int { return a * a }
    }
}


func main() {
    arguments := [][]int{{4,5},{6},{9},{7,18},{33}}
    var result int
    for _, a := range arguments {
        if len(a) == 1 {
            op := GetUnaryOp()
            result = op(a[0])            
        } else {
            op := GetBinaryOp()
            result = op(a[0], a[1])                    
        }
        fmt.Println(result)                
    }
}

Kanäle

Kanäle sind ein ungewöhnlicher Datentyp. Sie können sich diese als Nachrichtenwarteschlangen vorstellen, die zum Weiterleiten von Nachrichten zwischen Goroutinen verwendet werden. Kanäle sind stark typisiert. Sie sind synchronisiert und verfügen über eine spezielle Syntaxunterstützung zum Senden und Empfangen von Nachrichten. Jeder Kanal kann nur empfangen, nur senden oder bidirektional sein.

Optional können auch Kanäle gepuffert werden. Sie können die Nachrichten in einem Kanal mithilfe des Bereichs durchlaufen, und Go-Routinen können mithilfe der vielseitigen Auswahloperation mehrere Kanäle gleichzeitig blockieren.

Hier ist ein typisches Beispiel, bei dem die Summe der Quadrate einer Liste von Ganzzahlen parallel von zwei Go-Routinen berechnet wird, von denen jede für die Hälfte der Liste verantwortlich ist. Die Hauptfunktion wartet auf Ergebnisse aus beiden Go-Routinen und addiert dann die Teilsummen für die Gesamtsumme. Beachten Sie, wie der Kanal c mit der integrierten Funktion make() erstellt wird und wie der Code über den speziellen Operator <- aus dem Kanal liest und in diesen schreibt.

package main

import "fmt"

func sum_of_squares(s []int, c chan int) {
    sum := 0
    for _, v := range s {
        sum += v * v
    }
    c <- sum // send sum to c
}

func main() {
    s := []int{11, 32, 81, -9, -14}

    c := make(chan int)
    go sum_of_squares(s[:len(s)/2], c)
    go sum_of_squares(s[len(s)/2:], c)
    sum1, sum2 := <-c, <-c // receive from c
    total := sum1 + sum2

    fmt.Println(sum1, sum2, total)
}

Dies kratzt nur die Oberfläche. Eine detaillierte Übersicht der Kanäle finden Sie unter:

Go

Let's Go: Golang Concurrency, Teil 2

Gigi Sayfan

Sammlungen

Go hat mehrere integrierte generische Sammlungen, in denen jeder Typ gespeichert werden kann. Diese Sammlungen sind speziell und Sie können keine eigenen generischen Sammlungen definieren. Die Sammlungen sind Arrays, Slices und Maps. Kanäle sind ebenfalls generisch und können auch als Sammlungen betrachtet werden, aber sie haben einige ziemlich einzigartige Eigenschaften, daher ziehe ich es vor, sie separat zu diskutieren.

Arrays

Arrays sind Sammlungen von Elementen desselben Typs mit fester Größe. Hier sind einige Arrays:

package main
import "fmt"


func main() {
    a1 := [3]int{1, 2, 3}
    var a2 [3]int
    a2 = a1 

    fmt.Println(a1)
    fmt.Println(a2)
    
    a1[1] = 7

    fmt.Println(a1)
    fmt.Println(a2)
    
    a3 := [2]interface{}{3, "hello"}
    fmt.Println(a3)
}

Die Größe des Arrays ist Teil seines Typs. Sie können Arrays des gleichen Typs und der gleichen Größe kopieren. Die Kopie ist nach Wert. Wenn Sie Elemente unterschiedlichen Typs speichern möchten, können Sie die Escape-Schraffur eines Arrays leerer Schnittstellen verwenden.

Slices

Arrays sind aufgrund ihrer festen Größe ziemlich begrenzt. Scheiben sind viel interessanter. Sie können sich Slices als dynamische Arrays vorstellen. Unter der Decke verwenden Slices ein Array zum Speichern ihrer Elemente. Sie können die Länge eines Slice überprüfen, Elemente und andere Slices anhängen und am meisten Spaß daran haben, Sub-Slices zu extrahieren, die dem Python-Slicing ähneln:

package main

import "fmt"



func main() {
    s1 := []int{1, 2, 3}
    var s2 []int
    s2 = s1 

    fmt.Println(s1)
    fmt.Println(s2)

    // Modify s1    
    s1[1] = 7

    // Both s1 and s2 point to the same underlying array
    fmt.Println(s1)
    fmt.Println(s2)
    
    fmt.Println(len(s1))
    
    // Slice s1
    s3 := s1[1:len(s1)]
    
    fmt.Println(s3)
}

Wenn Sie Slices kopieren, kopieren Sie einfach den Verweis auf dasselbe zugrunde liegende Array. Wenn Sie schneiden, zeigt das Unter-Slice immer noch auf dasselbe Array. Wenn Sie jedoch anhängen, erhalten Sie ein Slice, das auf ein neues Array verweist.

Sie können Arrays oder Slices mithilfe einer regulären Schleife mit Indizes oder mithilfe von Bereichen durchlaufen. Sie können auch Slices mit einer bestimmten Kapazität erstellen, die mit dem Wert Null ihres Datentyps mit der Funktion make() initialisiert werden:

package main

import "fmt"



func main() {
    // Create a slice of 5 booleans initialized to false    
    s1 := make([]bool, 5)
    fmt.Println(s1)
    
    s1[3] = true
    s1[4] = true

    fmt.Println("Iterate using standard for loop with index")
    for i := 0; i < len(s1); i++ {
        fmt.Println(i, s1[i])
    }
    
    fmt.Println("Iterate using range")
    for i, x := range(s1) {
        fmt.Println(i, x)
    }
}

Output:

[false false false false false]
Iterate using standard for loop with index
0 false
1 false
2 false
3 true
4 true
Iterate using range
0 false
1 false
2 false
3 true
4 true

Maps

Karten sind Sammlungen von Schlüssel-Wert-Paaren. Sie können ihnen Kartenliterale oder andere Karten zuweisen. Sie können auch leere Karten mit der integrierten Funktion make erstellen. Sie greifen mit eckigen Klammern auf Elemente zu. Maps unterstützen die Iteration mithilfe des range. Sie können testen, ob ein Schlüssel vorhanden ist, indem Sie versuchen, darauf zuzugreifen, und den zweiten optionalen booleschen Rückgabewert überprüfen.

package main

import (
    "fmt"
)

func main() {
    // Create map using a map literal
    m := map[int]string{1: "one", 2: "two", 3:"three"}
    
    // Assign to item by key
    m[5] = "five"
    // Access item by key
    fmt.Println(m[2])
    
    v, ok := m[4]
    if ok {
        fmt.Println(v)
    } else {
        fmt.Println("Missing key: 4")
    }
    
    
    for k, v := range m {
        fmt.Println(k, ":", v)
    }
}

Output:

two
Missing key: 4
5 : five
1 : one
2 : two
3 : three

Beachten Sie, dass die Iteration nicht in der Erstellungs- oder Einfügereihenfolge erfolgt.

Zero Values

Es gibt keine nicht initialisierten Typen in Go. Jeder Typ hat einen vordefinierten Zero Value. Wenn eine Variable eines Typs deklariert wird, ohne ihr einen Wert zuzuweisen, enthält sie ihren Zero Value. Dies ist ein wichtiges Sicherheitsmerkmal.

Für jeden Typ T gibt *new(T) einen Zero Value von T zurück.

Bei booleschen Typen ist der Zero Value "false". Bei numerischen Typen ist der Zero Value... Zero. Für Slices, Maps und Zeiger ist es gleich Zero. Bei Strukturen handelt es sich um eine Struktur, bei der alle Felder auf ihren Zero Value initialisiert werden.

package main

import (
    "fmt"
)


type S struct {
    a float64
    b string
}

func main() {
    fmt.Println(*new(bool))
    fmt.Println(*new(int))
    fmt.Println(*new([]string))
    fmt.Println(*new(map[int]string))
    x := *new([]string)
    if x == nil {
        fmt.Println("Uninitialized slices are nil")
    }

    y := *new(map[int]string)
    if y == nil {
        fmt.Println("Uninitialized maps are nil too")
    }
    fmt.Println(*new(S))
}

Was ist mit Vorlagen oder Generika?

Go hat keine. Dies ist wahrscheinlich die häufigste Beschwerde über das Typsystem von Go. Die Go-Designer sind offen für die Idee, wissen aber noch nicht, wie sie umgesetzt werden sollen, ohne die anderen der Sprache zugrunde liegenden Gestaltungsprinzipien zu verletzen. Was können Sie tun, wenn Sie einige generische Datentypen dringend benötigen? Hier einige Vorschläge:

Wenn Sie nur wenige Instanziierungen haben, sollten Sie nur konkrete Objekte erstellen.
Verwenden Sie eine leere Schnittstelle (Sie müssen irgendwann Assert zurück zu Ihrem konkreten Typ eingeben).
Verwenden Sie die Codegenerierung.

Schlussfolgerung

Go hat ein interessantes Typensystem. Die Go-Designer haben explizite Entscheidungen getroffen, um auf der einfachen Seite des Spektrums zu bleiben. Wenn Sie es mit der Go-Programmierung ernst meinen, sollten Sie Zeit investieren und sich über das Typsystem und die Besonderheiten informieren. Es wird Ihre Zeit wert sein.