Tipe Data di Golang: int, float64, string, bool, byte, rune

Tipe dasar Go adalah angka, boolean, dan string. Setiap variabel punya tepat satu tipe, yang sudah tetap saat kompilasi, dan Go tidak pernah mengonversi antar tipe untukmu. %T mencetak tipe dari nilai apa pun:

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

Perhatikan bahwa 'G' dicetak sebagai 71 dengan tipe int32: karakter dalam tanda kutip tunggal adalah rune, yaitu sebuah angka (code point Unicode). rune adalah alias untuk int32 (tipe yang sama dengan nama kedua), jadi %T melaporkan int32. Begitu juga byte melaporkan uint8.

Integer

Pakai int secara default. len() mengembalikan int, indeks slice bertipe int, dan counter loop bertipe int. Di setiap platform 64-bit, int berukuran 64 bit. Pakai tipe berukuran tertentu saat ukurannya menjadi bagian dari kesepakatan: int32 di format file biner, uint8 untuk byte mentah, int64 untuk Unix timestamp dalam nanodetik.

Hindari tipe unsigned untuk besaran yang "tidak mungkin negatif", seperti jumlah. Mengurangi melewati nol akan berputar menjadi angka yang sangat besar, bukan angka negatif yang bisa kamu tangkap.

Batas dan overflow

Package math punya konstanta untuk setiap batas. Saat program berjalan, aritmetika integer yang overflow akan berputar balik diam-diam:

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

Tidak ada panic, tidak ada error: 127 + 1 menjadi -128. Hanya ekspresi konstanta yang diperiksa saat kompilasi (var b int8 = 128 tidak bisa dikompilasi). Kalau overflow mungkin terjadi pada datamu, periksa sebelum operasinya atau pakai math/big.

Literal integer

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

Bilangan Floating-Point

Literal dengan titik desimal atau eksponen (2.5, 1e6) bertipe float64 secara default, dan package math menerima serta mengembalikan float64. Pakai tipe ini kecuali memori di array besar menjadi masalah.

Float bersifat biner, jadi kebanyakan pecahan desimal hanyalah perkiraan:

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

Dari sini muncul dua aturan. Jangan pernah membandingkan float dengan == setelah aritmetika. Dan jangan pernah menyimpan uang dalam float: pakai integer berupa jumlah sen, atau library desimal.

Membagi float dengan nol menghasilkan +Inf, -Inf, atau NaN, bukan panic. Membagi integer dengan nol akan panic saat program berjalan (runtime error: integer divide by zero), dan pembagi berupa konstanta nol adalah error kompilasi.

Boolean

bool menyimpan true atau false, dan zero value-nya adalah false. Go tidak memperlakukan angka, string kosong, atau nil sebagai boolean. if count {} adalah error kompilasi; tulis if count > 0 {}. Operatornya adalah &&, ||, dan !, dan && serta || melakukan short-circuit.

String

string adalah urutan byte yang immutable, biasanya berupa teks UTF-8. len(s) menghitung byte, bukan karakter:

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

é memakai dua byte di UTF-8, jadi len melaporkan 6 untuk lima karakter. String dengan tanda kutip ganda memproses escape seperti \n; raw string dengan backquote tidak, dan bisa terdiri dari beberapa baris. Halaman string membahas package strings, dan halaman rune dan byte membahas UTF-8 secara mendalam.

byte dan rune

Keduanya alias, bukan tipe baru: byte dan uint8 bisa saling dipertukarkan tanpa konversi. Namanya menjelaskan arti angka tersebut.

Bilangan Kompleks

Go punya tipe kompleks bawaan, complex64 dan complex128, dengan real, imag, dan package 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))
}

Hanya sedikit program yang membutuhkannya, tetapi pemrosesan sinyal dan sebagian kode numerik memakainya.

Tipe Komposit dan Referensi

Tipe dasar bisa digabungkan menjadi tipe komposit. Masing-masing punya halamannya sendiri:

any adalah alias untuk interface{} (sejak Go 1.18) dan bisa menyimpan nilai bertipe apa pun.

Tipe Bernama

Kamu bisa mendefinisikan tipe baru dari tipe yang sudah ada. Representasinya sama, tetapi tipenya berbeda, dan tipe itu bisa punya method:

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

Ketatnya aturan ini justru intinya: UserID tidak bisa tanpa sengaja dikirim ke tempat yang mengharapkan OrderID. Konversi secara eksplisit kalau memang itu maksudmu: float64(t). Lihat konversi tipe untuk aturannya, dan fungsi-fungsi strconv untuk berpindah antara angka dan string.

Zero Value

Setiap tipe punya zero value, yaitu nilai yang disimpan variabel sebelum kamu meng-assign apa pun: 0 untuk angka, false untuk bool, "" untuk string, dan nil untuk pointer, slice, map, channel, fungsi, dan interface. Di Go tidak ada variabel yang belum diinisialisasi.