Golang Datentypen: int, float64, string, bool, byte, rune

Die Basistypen von Go sind Zahlen, Booleans und Strings. Jede Variable hat genau einen Typ, der zur Compilezeit feststeht, und Go konvertiert nie von selbst zwischen Typen. %T gibt den Typ jedes Werts aus:

package main

import "fmt"

func main() {
	count := 42
	price := 19.99
	name := "gopher"
	ok := true
	initial := 'G'
	raw := byte('G')
	z := 3 + 4i

	fmt.Printf("%-8v %T\n", count, count)
	fmt.Printf("%-8v %T\n", price, price)
	fmt.Printf("%-8v %T\n", name, name)
	fmt.Printf("%-8v %T\n", ok, ok)
	fmt.Printf("%-8v %T\n", initial, initial)
	fmt.Printf("%-8v %T\n", raw, raw)
	fmt.Printf("%v %T\n", z, z)
}

Beachte, dass 'G' als 71 mit dem Typ int32 ausgegeben wird: Ein Zeichen in einfachen Anführungszeichen ist eine Rune, und die ist eine Zahl (der Unicode-Codepoint). rune ist ein Alias für int32 (derselbe Typ unter einem zweiten Namen), also meldet %T int32. Ebenso meldet byte uint8.

Ganzzahlen

Nimm standardmäßig int. len() gibt int zurück, Slice-Indizes sind int, und Schleifenzähler sind int. Auf jeder 64-Bit-Plattform hat int 64 Bit. Zu Typen mit fester Größe greifst du, wenn die Größe Teil eines Vertrags ist: int32 in einem binären Dateiformat, uint8 für Rohbytes, int64 für einen Unix-Zeitstempel in Nanosekunden.

Vermeide vorzeichenlose Typen für Mengen, die „nicht negativ sein können“, etwa Anzahlen. Subtrahierst du über null hinaus, springt der Wert auf eine riesige Zahl, statt eine negative zu ergeben, die du abfangen könntest.

Grenzen und Überlauf

Das Paket math hat für jede Grenze eine Konstante. Zur Laufzeit läuft Ganzzahlarithmetik, die überläuft, still herum:

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MaxInt:  ", math.MaxInt)
	fmt.Println("MaxInt32:", math.MaxInt32)
	fmt.Println("MaxUint8:", math.MaxUint8)

	var small int8 = 127
	small++
	fmt.Println("127 + 1 as int8:", small)

	var u uint = 0
	u--
	fmt.Println("0 - 1 as uint:", u)

	var n int32 = math.MaxInt32
	fmt.Println("MaxInt32 * 2:", n*2)
}

Keine Panic, kein Fehler: 127 + 1 wird zu -128. Nur konstante Ausdrücke werden zur Compilezeit geprüft (var b int8 = 128 kompiliert nicht). Kann in deinen Daten ein Überlauf auftreten, prüf vor der Operation oder nimm math/big.

Ganzzahlliterale

million := 1_000_000   // underscores for readability (Go 1.13+)
mask := 0xFF           // hexadecimal
perm := 0o755          // octal (also the older form 0755)
flags := 0b1010        // binary

Gleitkommazahlen

Ein Literal mit Dezimalpunkt oder Exponent (2.5, 1e6) ist standardmäßig float64, und das Paket math nimmt und liefert float64. Nimm es, außer der Speicher in einem großen Array zählt.

Floats sind binär, also sind die meisten Dezimalbrüche Näherungen:

package main

import (
	"fmt"
	"math"
)

func main() {
	a := 0.1
	b := 0.2
	fmt.Println(a+b, a+b == 0.3)

	// compare with a tolerance instead
	fmt.Println(math.Abs((a+b)-0.3) < 1e-9)

	// integer division vs float division
	fmt.Println(7/2, 7.0/2, float64(7)/2)

	// special values
	zero := 0.0
	fmt.Println(1/zero, -1/zero, math.NaN())
}

Daraus folgen zwei Regeln. Vergleiche Floats nach Berechnungen nie mit ==. Und speichere Geld nie in einem Float: Nimm eine ganze Zahl von Cent oder eine Dezimalbibliothek.

Einen Float durch null zu teilen ergibt +Inf, -Inf oder NaN statt einer Panic. Eine Ganzzahl durch null zu teilen löst zur Laufzeit eine Panic aus (runtime error: integer divide by zero), und ein konstanter Divisor null ist ein Compilerfehler.

Booleans

bool enthält true oder false, und sein Nullwert ist false. Go behandelt Zahlen, leere Strings oder nil nicht als Booleans. if count {} ist ein Compilerfehler; schreib if count > 0 {}. Die Operatoren sind &&, || und !, und && und || werten kurzschließend aus.

Strings

Ein string ist eine unveränderliche Folge von Bytes, meist UTF-8-Text. len(s) zählt Bytes, keine Zeichen:

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "héllo"
	fmt.Println(len(s))                    // bytes
	fmt.Println(utf8.RuneCountInString(s)) // characters
	fmt.Println(s[0], string(s[0]))        // indexing gives a byte

	multiline := `raw string:
backslashes \n stay as written`
	fmt.Println(multiline)
}

é belegt in UTF-8 zwei Bytes, also meldet len 6 für fünf Zeichen. Strings in doppelten Anführungszeichen verarbeiten Escapes wie \n; Raw Strings in Backquotes tun das nicht und können über mehrere Zeilen gehen. Die Seite zu Strings behandelt das Paket strings, und die Seite zu Runes und Bytes erklärt UTF-8 im Detail.

byte und rune

Das sind Aliase, keine neuen Typen: Ein byte und ein uint8 sind ohne Konvertierung austauschbar. Die Namen sagen, was die Zahl bedeutet.

Komplexe Zahlen

Go hat eingebaute komplexe Typen, complex64 und complex128, mit real, imag und dem Paket math/cmplx:

package main

import (
	"fmt"
	"math/cmplx"
)

func main() {
	c := complex(3, 4) // complex128
	fmt.Println(c, real(c), imag(c))
	fmt.Println(cmplx.Abs(c))
	fmt.Println(cmplx.Sqrt(-1))
}

Wenige Programme brauchen sie, aber Signalverarbeitung und mancher numerische Code schon.

Zusammengesetzte Typen und Referenztypen

Die Basistypen lassen sich zu zusammengesetzten kombinieren. Jeder hat seine eigene Seite:

any ist (seit Go 1.18) ein Alias für interface{} und kann einen Wert beliebigen Typs enthalten.

Benannte Typen

Du kannst aus einem vorhandenen Typ einen neuen definieren. Er hat dieselbe Darstellung, ist aber ein eigener Typ und kann Methoden haben:

type Celsius float64
type UserID int64

var t Celsius = 21.5
var f float64 = t // compile error: cannot use t (variable of float64 type Celsius) as float64 value in variable declaration

Genau diese Strenge ist der Sinn: Eine UserID lässt sich nicht versehentlich übergeben, wo eine OrderID erwartet wird. Konvertiere explizit, wenn du es so meinst: float64(t). Die Regeln stehen auf der Seite zur Typkonvertierung, und für den Weg zwischen Zahlen und Strings gibt es die Funktionen aus strconv.

Nullwerte

Jeder Typ hat einen Nullwert. Den enthält eine Variable, bevor du ihr etwas zuweist: 0 für Zahlen, false für bool, "" für Strings und nil für Pointer, Slices, Maps, Channels, Funktionen und Interfaces. Nicht initialisierte Variablen gibt es in Go nicht.