Tipe Data

Setiap nilai di Go memiliki tepat satu tipe yang menentukan ukuran memori, operasi yang sah, dan nilai awalnya. Go tidak memiliki konversi implisit antar tipe, sehingga menghafal daftar tipe bawaan beserta rentangnya menghemat banyak waktu debugging. Chapter ini merangkum seluruh tipe bawaan — dari bool hingga complex128 — beserta zero value, rentang nilai numerik, dan tipe komposit yang dibangun darinya. Seluruh angka pada tabel di bawah telah diverifikasi dengan program pada bagian akhir chapter.

Tipe Boolean dan String #

Dua tipe fundamental ini menjadi fondasi hampir setiap program. Keduanya dibahas mendalam pada chapter Variabel dan String dan Rune .

Perlu dicatat bahwa len pada string menghitung byte, bukan jumlah karakter — string berisi teks non-ASCII bisa berisi lebih banyak byte daripada karakter yang terlihat.

Tipe Bilangan Bulat #

Go membedakan tipe bertanda (int) dan tak bertanda (uint) dalam empat lebar bit. Tipe byte dan rune adalah alias yang membuat niat kode lebih jelas: byte untuk data mentah, rune untuk karakter Unicode.

Nilai di luar rentang akan ditolak compiler, bukan dibungkus diam-diam — percobaan memasukkan 200 ke int8 menghasilkan pesan overflows yang dibahas pada chapter Compiler Error . Praktik umum: gunakan int untuk bilangan bulat biasa, dan tipe berlebar tetap hanya saat format data memang mensyaratkan (protokol biner, penyimpanan hemat memori).

Tipe Floating-Point dan Kompleks #

Angka floating-point mengikuti standar IEEE 754, sehingga operasi seperti pembagian dengan nol menghasilkan +Inf, bukan panic. Untuk perhitungan uang atau nilai yang harus tepat, gunakan representasi bilangan bulat (misalnya jumlah rupiah dalam int64), bukan floating-point.

Tipe Komposit #

Tipe komposit dibangun dari tipe dasar. Zero value-nya konsisten: tipe referensi menjadi nil, sedangkan array dan struct diisi zero value di setiap elemen atau field-nya.

Tiga identifier tipe terpasang melengkapi daftar ini: error (interface satu method Error() string), any (alias interface{}), dan comparable (constraint untuk tipe yang bisa dibandingkan dengan ==). Ketiganya bukan keyword — pembahasan lengkapnya ada di chapter Interface .

Membuktikan Zero Value dan Rentang #

Berkas zero-value-demo.go mendeklarasikan sepuluh tipe dalam satu blok var tanpa nilai awal, lalu mencetak isi serta batas numerik dari konstanta package math:

package main

import (
	"fmt"
	"math"
)

func main() {
	var (
		aktif    bool
		nama     string
		jumlah   int
		rasio    float64
		ptr      *int
		daftar   []int
		indeks   map[string]int
		fungsi   func()
		saluran  chan int
		pengguna struct {
			Nama string
			Umur int
		}
	)
	fmt.Printf("bool    : %v\n", aktif)
	fmt.Printf("string  : %q\n", nama)
	fmt.Printf("int     : %v\n", jumlah)
	fmt.Printf("float64 : %v\n", rasio)
	fmt.Printf("*int    : %#v\n", ptr)
	fmt.Printf("[]int   : %#v\n", daftar)
	fmt.Printf("map     : %#v\n", indeks)
	fmt.Printf("func    : %#v\n", fungsi)
	fmt.Printf("chan    : %#v\n", saluran)
	fmt.Printf("struct  : %#v\n", pengguna)
	fmt.Println("int8    :", math.MinInt8, "sampai", math.MaxInt8)
	fmt.Println("uint8   : 0 sampai", math.MaxUint8)
	fmt.Println("int16   :", math.MinInt16, "sampai", math.MaxInt16)
	fmt.Println("uint16  : 0 sampai", math.MaxUint16)
	fmt.Println("int32   :", math.MinInt32, "sampai", math.MaxInt32)
	fmt.Println("uint32  : 0 sampai", math.MaxUint32)
	fmt.Println("int64   :", math.MinInt64, "sampai", math.MaxInt64)
	fmt.Println("float64 :", math.MaxFloat64)
}

Output yang Dihasilkan:

bool    : false
string  : ""
int     : 0
float64 : 0
*int    : (*int)(nil)
[]int   : []int(nil)
map     : map[string]int(nil)
func    : (func())(nil)
chan    : (chan int)(nil)
struct  : struct { Nama string; Umur int }{Nama:"", Umur:0}
int8    : -128 sampai 127
uint8   : 0 sampai 255
int16   : -32768 sampai 32767
uint16  : 0 sampai 65535
int32   : -2147483648 sampai 2147483647
uint32  : 0 sampai 4294967295
int64   : -9223372036854775808 sampai 9223372036854775807
float64 : 1.7976931348623157e+308

Mari kita telaah bagian-bagian penting program di atas:

1. Baris 9-23 (blok var): sepuluh variabel dideklarasikan tanpa nilai awal dalam satu grup; compiler mengisi masing-masing dengan zero value tipenya.
2. Baris 24-27 (verb %v dan %q): verb %q mencetak string dengan tanda kutip sehingga string kosong terlihat jelas sebagai "".
3. Baris 28-33 (verb %#v): representasi sintaks Go menunjukkan bentuk nil secara eksplisit — (*int)(nil), []int(nil), hingga (chan int)(nil).
4. Baris 34-41 (konstanta math): math.MinInt8 dan kawan-kawannya mencetak rentang resmi tiap tipe; hasilnya cocok dengan tabel bilangan bulat di atas.

Referensi #

• Spesifikasi Go — Numeric types — definisi resmi rentang setiap tipe numerik.
• Spesifikasi Go — Predeclared identifiers — lokasi resmi byte, rune, error, any, dan comparable.

Setelah mengenal seluruh tipe, langkah berikutnya adalah mengoperasikannya: operator beserta urutan prioritas evaluasinya dirangkum pada chapter Operator .

package main

import (
	"fmt"
	"math"
)

func main() {
	var (
		aktif    bool
		nama     string
		jumlah   int
		rasio    float64
		ptr      *int
		daftar   []int
		indeks   map[string]int
		fungsi   func()
		saluran  chan int
		pengguna struct {
			Nama string
			Umur int
		}
	)
	fmt.Printf("bool    : %v\n", aktif)
	fmt.Printf("string  : %q\n", nama)
	fmt.Printf("int     : %v\n", jumlah)
	fmt.Printf("float64 : %v\n", rasio)
	fmt.Printf("*int    : %#v\n", ptr)
	fmt.Printf("[]int   : %#v\n", daftar)
	fmt.Printf("map     : %#v\n", indeks)
	fmt.Printf("func    : %#v\n", fungsi)
	fmt.Printf("chan    : %#v\n", saluran)
	fmt.Printf("struct  : %#v\n", pengguna)
	fmt.Println("int8    :", math.MinInt8, "sampai", math.MaxInt8)
	fmt.Println("uint8   : 0 sampai", math.MaxUint8)
	fmt.Println("int16   :", math.MinInt16, "sampai", math.MaxInt16)
	fmt.Println("uint16  : 0 sampai", math.MaxUint16)
	fmt.Println("int32   :", math.MinInt32, "sampai", math.MaxInt32)
	fmt.Println("uint32  : 0 sampai", math.MaxUint32)
	fmt.Println("int64   :", math.MinInt64, "sampai", math.MaxInt64)
	fmt.Println("float64 :", math.MaxFloat64)
}