Go, auch bekannt als Golang, ist eine statisch typisierte Sprache. Dies bedeutet, dass der Typ jeder Variablen zur Kompilierungszeit bekannt ist, was für Sicherheit und Vorhersehbarkeit in Ihrem Code sorgt. Dies erfordert jedoch auch, dass jede Umwandlung von einem Typ in einen anderen explizit und bewusst erfolgt. In diesem Artikel untersuchen wir die verschiedenen in Go verfügbaren Typumwandlungs- und Konvertierungsmechanismen, von einfachen numerischen Konvertierungen bis hin zu komplexeren Schnittstellen- und Zeigerkonvertierungen.

1. Grundlegende Typkonvertierungen

Go ermöglicht die Konvertierung zwischen Grundtypen wie Ganzzahlen, Gleitkommazahlen und Zeichenfolgen, diese Konvertierungen müssen jedoch explizit durchgeführt werden.

Numerische Typen

Konvertierungen zwischen verschiedenen numerischen Typen sind unkompliziert, müssen jedoch explizit sein:

var i int = 42
var f float64 = float64(i)  // int to float64
var u uint = uint(i)        // int to uint

In diesem Beispiel konvertieren wir ein int in ein float64 und in ein uint. Diese Konvertierungen sind explizit, da Go keine automatischen (impliziten) Typkonvertierungen durchführt.

String- und Byte-Slice

Go-Strings sind unveränderlich, können aber in und aus Byte-Slices ([]Byte) konvertiert werden, die veränderbar sind:

var s string = "hello"
var b []byte = []byte(s)   // string to []byte
var s2 string = string(b)  // []byte to string

Ähnlich können Sie zwischen Strings und Runen-Slices konvertieren ([]rune), wobei rune ein Typalias für int32 ist:

var r []rune = []rune(s)   // string to []rune
var s3 string = string(r)  // []rune to string

2. Benutzerdefinierte Typkonvertierungen

In Go können Sie Ihre eigenen Typen basierend auf vorhandenen definieren. Konvertierungen zwischen benutzerdefinierten Typen und den ihnen zugrunde liegenden Typen sind explizit:

type MyInt int
var i int = 10
var mi MyInt = MyInt(i)   // int to MyInt
var i2 int = int(mi)      // MyInt to int

Diese explizite Konvertierung ist notwendig, um sicherzustellen, dass der Compiler die Sicherheit Ihres Codes überprüfen kann.

3. Zeigerkonvertierungen

Zeiger in Go verweisen auf die Speicheradresse einer Variablen. Sie können zwischen einem Wert und seinem Zeiger konvertieren:

var x int = 42
var p *int = &x     // int to *int (pointer to int)
var y int = *p      // *int to int (dereferencing)

4. Konvertierungen von Schnittstellentypen

Schnittstellen in Go werden verwendet, um eine Reihe von Methoden zu definieren. Sie können zwischen konkreten Typen und Schnittstellen konvertieren:

var a interface{} = 42    // int to interface{}
var b int = a.(int)       // interface{} to int (type assertion)

Geben Sie Behauptungen ein

Eine Typzusicherung bietet Zugriff auf den konkreten Wert einer Schnittstelle:

if v, ok := a.(int); ok {
    fmt.Println("a is an int:", v)
}

Geben Sie Schalter ein

Mit einem Typschalter können Sie verschiedene Aktionen basierend auf dem dynamischen Typ einer Schnittstelle ausführen:

switch v := a.(type) {
case int:
    fmt.Println("a is an int:", v)
case string:
    fmt.Println("a is a string:", v)
default:
    fmt.Println("a is of unknown type")
}

5. Unsichere Konvertierungen

Das unsichere Paket ermöglicht es Ihnen, die Typsicherheit von Go zu umgehen und so Konvertierungen zu ermöglichen, die andernfalls illegal wären:

import "unsafe"

var i int = 42
var p *int = &i
var fp *float64 = (*float64)(unsafe.Pointer(p))  // *int to *float64

Warnung: Unsichere Konvertierungen sollten sparsam und nur dann eingesetzt werden, wenn dies unbedingt erforderlich ist, da sie zu undefiniertem Verhalten führen können.

6. Kanaltypkonvertierungen

Kanäle sind eine leistungsstarke Funktion in Go, die die Kommunikation zwischen Goroutinen ermöglicht. Sie können zwischen bidirektionalen und unidirektionalen Kanälen konvertieren:

ch := make(chan int)
var sendOnlyChan chan




  
  
  7. Struktur- und Array-Konvertierungen


Konvertierungen zwischen Strukturen oder Arrays mit identischen Layouts erfordern eine explizite Umwandlung:


type Point struct {
    X, Y int
}

type Coord struct {
    X, Y int
}

var p Point = Point{1, 2}
var c Coord = Coord(p)  // Convert Point to Coord (same field types)





  
  
  8. Slice-Konvertierungen


Slices sind Verweise auf Arrays, und während Sie zwischen Slices desselben Typs konvertieren können, erfordert die Konvertierung zwischen verschiedenen Slices-Typen eine explizite Konvertierung:


var a []int = []int{1, 2, 3}
var b []int = a[1:]  // Convert a slice to another slice of the same type





  
  
  9. Null-Schnittstellenkonvertierungen


Ein Nullwert in Go kann jedem Schnittstellentyp zugewiesen werden:


var x interface{} = nil
var y error = nil





  
  
  10. Funktionstypkonvertierungen


Go-Funktionen können in verschiedene Typen konvertiert werden, sofern die Signaturen kompatibel sind:


type FuncType func(int) int

func square(x int) int {
    return x * x
}

var f FuncType = FuncType(square)  // Convert function to FuncType





  
  
  11. Array-zu-Slice-Konvertierung


Sie können ein Slice aus einem Array erstellen, das im Wesentlichen eine Referenz auf das Array ist:


var arr [5]int = [5]int{1, 2, 3, 4, 5}
var sl []int = arr[:]  // Convert array to slice





  
  
  Abschluss


Typumwandlungen und -konvertierungen in Go sind vom Design her explizit, wodurch der Code sicherer und leichter verständlich wird. Durch das Erfordernis expliziter Konvertierungen trägt Go dazu bei, subtile Fehler zu vermeiden, die durch implizite Typerzwingung entstehen können, die in einigen anderen Programmiersprachen häufig vorkommt. Das Verstehen dieser Konvertierungen und ihre korrekte Verwendung ist entscheidend für das Schreiben robuster und effizienter Go-Programme.