Informationen zu Standarddatentypen

8 Minuten

Go ist eine stark typisierte Sprache. Jede deklarierte Variable ist an einen bestimmten Datentyp gebunden und akzeptiert nur die Werte, die diesem Typ entsprechen.

In Go gibt es vier Kategorien von Datentypen:

Standardtypen: Zahlen, Zeichenfolgen und boolesche Werte
Aggregattypen: Arrays und Strukturen
Verweistypen: Zeiger, Slices, Zuordnungen, Funktionen und Kanäle
Schnittstellentypen: Schnittstelle

In diesem Modul werden nur die Standardtypen behandelt. Es ist kein Problem, wenn Sie die anderen Typen nicht kennen. Diese werden in den nächsten Modulen behandelt.

Lassen Sie uns zunächst die numerischen Datentypen untersuchen.

Ganze Zahlen

Generell lautet das Stichwort zum Definieren eines ganzzahligen Typs int. Go bietet aber auch die Typen int8, int16, int32 und int64 an, bei denen es sich um int-Werte mit einer Größe von 8, 16, 32 bzw. 64 Bit handelt. Wenn Sie bei 32-Bit-Betriebssystemen nur int verwenden, beträgt die Größe in der Regel 32 Bits. Bei 64-Bit-Systemen beträgt die int-Größe in der Regel 64 Bits. Dieses Verhalten kann sich allerdings von Computer zu Computer unterscheiden. Sie können uint verwenden. Verwenden Sie diesen Typ jedoch nur, wenn Sie einen Wert aus einem bestimmten Grund als Zahl ohne Vorzeichen darstellen müssen. Ebenso umfasst Go uint8-, uint16-, uint32-und uint64-Typen.

Nachfolgend finden Sie Beispiele für die verschiedenen ganzzahligen Typen in Go:

var integer8 int8 = 127
var integer16 int16 = 32767
var integer32 int32 = 2147483647
var integer64 int64 = 9223372036854775807
fmt.Println(integer8, integer16, integer32, integer64)

In den meisten Fällen werden Sie int verwenden, aber Sie müssen die anderen ganzzahligen Typen kennen, weil int in Go nicht dasselbe wie int32 ist – nicht einmal, wenn die natürliche Größe der ganzen Zahl 32 Bit beträgt. Anders ausgedrückt: Sie müssen Umwandlungen explizit veranlassen, wenn dies erforderlich ist. Wenn Sie versuchen, einen mathematischen Vorgang zwischen verschiedenen Typen auszuführen, wird eine Fehlermeldung ausgelöst. Nehmen Sie z. B. an, Sie hätten folgenden Code:

var integer16 int16 = 127
var integer32 int32 = 32767
fmt.Println(integer16 + integer32)

Wenn Sie das Programm ausführen, wird die folgende Fehlermeldung angezeigt:

invalid operation: integer16 + integer32 (mismatched types int16 and int32)

Wie Sie sehen können, müssen Sie beim Konvertieren eines Werts von einem Typ in einen anderen in Go den neuen Typ explizit angeben. Am Ende dieses Moduls erfahren Sie mehr darüber, wie Sie Typen richtig umwandeln.

Wenn Sie Ihre Kenntnisse zu Go vertiefen, werden Sie möglicherweise auf den Begriff Runes stoßen. rune ist einfach ein Alias für den Datentyp int32. Runes werden verwendet, um ein Unicodezeichen (oder einen Unicodecodepunkt) darzustellen. Angenommen, Sie verwenden den folgenden Code:

rune := 'G'
fmt.Println(rune)

Wenn Sie den obigen Codeausschnitt ausführen, erwarten Sie möglicherweise, dass das Programm G in der Eingabeaufforderung ausgibt. Sie sehen jedoch die Zahl 71, die das Unicodezeichen für G darstellt. In den nächsten Modulen werden wir uns ausgiebiger mit Runes beschäftigen.

Informationen zu den Bereichen für die einzelnen Typen finden Sie im Go-Quellcode. Wenn Sie die Bereiche der einzelnen Typen kennen, können Sie besser einen passenden Datentyp auswählen und vermeiden, dass Bits im Arbeitsspeicher verschwendet werden.

Herausforderung 1

Legen Sie eine andere Variable vom Typ int fest, und verwenden Sie den Wert aus der Variablen integer32 oder integer64, um die natürliche Größe der Variablen auf Ihrem System zu bestätigen. Wenn Sie auf einem 32-Bit-System einen höheren Wert als 2.147.483.647 verwenden, wird ein Überlauffehler ausgelöst. Die Fehlermeldung sieht dann wie folgt aus: constant 9223372036854775807 overflows int.

Aufgabenlösung:

package main

import "fmt"

func main() {
   var integer32 int = 2147483648
   fmt.Println(integer32)
}

Herausforderung 2

Deklarieren Sie eine Variable ohne Vorzeichen, z. B. uint, und initialisieren Sie diese mit einem negativen Wert wie -10. Wenn Sie versuchen, das Programm auszuführen, sollte eine Fehlermeldung wie die folgende angezeigt werden: constant -10 overflows uint.

Aufgabenlösung:

package main

import "fmt"

func main() {
   var integer uint = -10
   fmt.Println(integer)
}

Gleitkommazahlen

Go stellt Datentypen für zwei Größen von Gleitkommazahlen bereit: float32 und float64. Sie können diese Typen verwenden, wenn Sie große Zahlen speichern müssen, die nicht in die bereits erwähnten ganzzahligen Typen passen. Diese beiden Typen unterscheiden sich in der maximalen Bitgröße, die sie speichern können. Sehen Sie sich die folgenden Zeilen an, um zu erfahren, wie Sie diese beiden Typen verwenden können:

var float32 float32 = 2147483647
var float64 float64 = 9223372036854775807
fmt.Println(float32, float64)

Sie können die Grenzwerte dieser beiden Typen mithilfe der Konstanten math.MaxFloat32 und math.MaxFloat64 ermitteln, die im Paket math enthalten sind. Verwenden Sie den folgenden Code, um die maximalen Gleitkommawerte in der Eingabeaufforderung anzufordern:

package main

import (
    "fmt"
    "math"
)    

func main() {
    fmt.Println(math.MaxFloat32, math.MaxFloat64)
}

Gleitkommatypen sind ebenfalls nützlich, wenn Sie Dezimalzahlen verwenden müssen. Beispielsweise könnten Sie etwa folgenden Code schreiben:

const e = 2.71828
const Avogadro = 6.02214129e23
const Planck = 6.62606957e-34

Hinweis: Mit dem obigen Code leitet Go die Datentypen von den verwendeten Werten ab.

Boolesche Werte

Ein boolescher Typ hat nur zwei mögliche Werte: true und false. Sie können boolesche Werte mithilfe des Stichworts bool deklarieren. Go unterscheidet sich von anderen Programmiersprachen. Bei Go können Sie einen booleschen Typ nicht implizit in 0 oder 1 konvertieren. Dies müssen Sie explizit tun.

Deshalb können Sie eine boolesche Variable wie folgt deklarieren:

var featureFlag bool = true

Wir verwenden die booleschen Datentypen im nächsten Modul, wenn es um Ablaufsteuerungsanweisungen in Go geht. Auch in späteren Modulen werden diese Datentypen verwendet.

Zeichenfolgen

Nun möchten wir auf den in jeder Programmiersprache am häufigsten verwendeten Datentyp eingehen: die Zeichenfolge. In Go wird das Stichwort string verwendet, um Zeichenfolgendatentypen darzustellen. Wenn Sie eine Zeichenfolgenvariable initialisieren möchten, müssen Sie ihren Wert in doppelte Anführungszeichen setzen ("). Einfache Anführungszeichen (') werden für einzelne Zeichen verwendet (und für Runes, wie wir bereits gesehen haben).

Der folgende Code zeigt z. B. zwei Möglichkeiten, eine Zeichenfolgenvariable zu deklarieren und zu initialisieren:

var firstName string = "John"
lastName := "Doe"
fmt.Println(firstName, lastName)

Manchmal müssen Sie Escapezeichen verwenden. Fügen Sie dafür einen umgekehrten Schrägstrich (\) vor dem jeweiligen Zeichen ein. Nachfolgend finden Sie die häufigsten Beispiele für die Verwendung von Escapezeichen:

\n für neue Zeilen
\r für Wagenrückläufe
\t für Registerkarten
\' für einfache Anführungszeichen
\" für doppelte Anführungszeichen
\\ für umgekehrte Schrägstriche

Verwenden Sie den folgenden Codeausschnitt, um Escapezeichen zu testen:

fullName := "John Doe \t(alias \"Foo\")\n"
fmt.Println(fullName)

Dann sollte die folgende Ausgabe angezeigt werden (einschließlich der neuen Zeile):

John Doe        (alias "Foo")

Standardwerte

Bisher haben wir fast jedes Mal, wenn eine Variable deklariert wurde, diese mit einem Wert initialisiert. Aber im Gegensatz zu anderen Programmiersprachen weisen in Go alle Datentypen einen Standardwert auf, wenn Sie keine Variable initialisieren. Dieses Feature ist praktisch, weil Sie damit nicht überprüfen müssen, ob eine Variable initialisiert wurde, bevor Sie sie verwenden.

Nachfolgend werden einige Standardwerte für die Typen aufgeführt, die wir bisher untersucht haben:

0 für int-Typen (und alle zugehörigen Untertypen, z. B. int64)
+0.000000e+000 für float32- und float64-Typen
false für bool-Typen
Ein leerer Wert für string-Typen

Führen Sie den folgenden Codeausschnitt aus, um die oben aufgeführten Standardwerte zu bestätigen:

var defaultInt int
var defaultFloat32 float32
var defaultFloat64 float64
var defaultBool bool
var defaultString string
fmt.Println(defaultInt, defaultFloat32, defaultFloat64, defaultBool, defaultString)

Mithilfe von Code wie diesem können Sie den Standardwert für einen Datentyp ermitteln, den wir nicht in dieser Einheit untersucht haben.

Typkonvertierungen

In einem vorherigen Abschnitt haben wir bereits erwähnt, dass die implizite Umwandlung in Go nicht funktioniert. In Go muss die Umwandlung explizit durchgeführt werden. Go bietet einige native Möglichkeiten, um einen Datentyp in einen anderen zu konvertieren. Beispielsweise können Sie wie im folgenden Beispiel gezeigt die integrierte Funktion für jeden Typ verwenden:

var integer16 int16 = 127
var integer32 int32 = 32767
fmt.Println(int32(integer16) + integer32)

Ein weiterer Ansatz für die Umwandlung in Go ist die Verwendung des Pakets strconv. Wenn Sie z. B. eine string in einen int-Wert (oder umgekehrt) konvertieren möchten, können Sie den folgenden Code verwenden:

package main

import (
    "fmt"
    "strconv"
)

func main() {
    i, _ := strconv.Atoi("-42")
    s := strconv.Itoa(-42)
    fmt.Println(i, s)
}

Führen Sie den obigen Code aus, und vergewissern Sie sich, dass er zweimal ausgeführt wird und -42 zurückgibt.

Im obigen Code wird ein Unterstrich (_) als der Name einer Variablen verwendet. In Go bedeutet der _, dass der Wert dieser Variablen nicht verwendet wird und er ignoriert werden soll. Andernfalls wird das Programm nicht kompiliert, da alle deklarierten Variablen verwendet werden müssen. In den nachfolgenden Modulen wird dieses Thema aufgegriffen, und Sie erfahren, wofür der _ in der Regel steht.

Weiter