Typy danych w Go (Golang): int, float64, string, bool, byte, rune

Podstawowe typy Go to liczby, wartości logiczne i stringi. Każda zmienna ma dokładnie jeden typ, ustalony w czasie kompilacji, a Go nigdy nie konwertuje typów za ciebie. %T wypisuje typ dowolnej wartości:

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)
}

Zwróć uwagę, że 'G' wypisuje się jako 71 z typem int32: znak w apostrofach to runa, czyli liczba (punkt kodowy Unicode). rune to alias int32 (ten sam typ pod drugą nazwą), więc %T zgłasza int32. Podobnie byte zgłasza uint8.

Liczby całkowite

Domyślnie używaj int. len() zwraca int, indeksy slice'ów to int i liczniki pętli to int. Na każdej platformie 64-bitowej int ma 64 bity. Po typy o określonym rozmiarze sięgaj wtedy, gdy rozmiar jest częścią umowy: int32 w binarnym formacie pliku, uint8 dla surowych bajtów, int64 dla znacznika czasu Unix w nanosekundach.

Unikaj typów bez znaku dla wielkości, które "nie mogą być ujemne", takich jak liczniki. Odejmowanie poniżej zera zawija się do ogromnej liczby, zamiast dać wartość ujemną, którą dałoby się wyłapać.

Limity i przepełnienie

Pakiet math ma stałą dla każdego limitu. W czasie działania arytmetyka całkowita, która się przepełnia, po cichu się zawija:

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)
}

Bez panic, bez błędu: 127 + 1 staje się -128. W czasie kompilacji sprawdzane są tylko wyrażenia stałe (var b int8 = 128 się nie kompiluje). Jeśli w twoich danych możliwe jest przepełnienie, sprawdzaj przed operacją albo użyj math/big.

Literały całkowite

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

Liczby zmiennoprzecinkowe

Literał z kropką dziesiętną lub wykładnikiem (2.5, 1e6) jest domyślnie typu float64, a pakiet math przyjmuje i zwraca float64. Używaj go, chyba że liczy się pamięć w dużej tablicy.

Liczby zmiennoprzecinkowe są binarne, więc większość ułamków dziesiętnych to przybliżenia:

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())
}

Wynikają z tego dwie zasady. Nigdy nie porównuj floatów przez == po obliczeniach. I nigdy nie przechowuj pieniędzy we floatach: użyj liczby całkowitej groszy albo biblioteki liczb dziesiętnych.

Dzielenie floata przez zero daje +Inf, -Inf lub NaN zamiast panic. Dzielenie liczby całkowitej przez zero wywołuje panic w czasie działania (runtime error: integer divide by zero), a stały dzielnik równy zero to błąd kompilacji.

Wartości logiczne

bool przechowuje true lub false, a jego wartość zerowa to false. Go nie traktuje liczb, pustych stringów ani nil jako wartości logicznych. if count {} to błąd kompilacji; napisz if count > 0 {}. Operatory to &&, || i !, przy czym && i || działają skrótowo.

Stringi

string to niezmienny ciąg bajtów, zwykle tekst w UTF-8. len(s) liczy bajty, nie znaki:

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)
}

é zajmuje w UTF-8 dwa bajty, więc len zgłasza 6 dla pięciu znaków. Stringi w cudzysłowach przetwarzają sekwencje ucieczki, takie jak \n; surowe stringi w odwrotnych apostrofach tego nie robią i mogą obejmować wiele linii. Strona o stringach omawia pakiet strings, a strona o runach i bajtach szczegółowo opisuje UTF-8.

byte i rune

To aliasy, a nie nowe typy: byte i uint8 są wymienne bez konwersji. Nazwy mówią, co oznacza liczba.

Liczby zespolone

Go ma wbudowane typy zespolone, complex64 i complex128, a do tego real, imag i pakiet 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))
}

Potrzebuje ich niewiele programów, ale przetwarzanie sygnałów i część kodu numerycznego tak.

Typy złożone i referencyjne

Typy podstawowe łączą się w typy złożone. Każdy ma własną stronę:

any to alias interface{} (od Go 1.18) i może przechowywać wartość dowolnego typu.

Typy nazwane

Możesz zdefiniować nowy typ na podstawie istniejącego. Ma tę samą reprezentację, ale jest odrębnym typem i może mieć metody:

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

Ta surowość jest celowa: UserID nie da się przypadkiem przekazać tam, gdzie oczekiwany jest OrderID. Gdy naprawdę tego chcesz, konwertuj jawnie: float64(t). Zasady opisuje strona o konwersji typów, a do przechodzenia między liczbami i stringami służą funkcje z strconv.

Wartości zerowe

Każdy typ ma wartość zerową, czyli to, co zmienna przechowuje, zanim cokolwiek do niej przypiszesz: 0 dla liczb, false dla bool, "" dla stringów oraz nil dla wskaźników, slice'ów, map, kanałów, funkcji i interfejsów. W Go nie ma niezainicjalizowanych zmiennych.