Cara Menggunakan Variabel dan Tipe Data di Go

Pendahuluan

Bayangkan kamu sedang membangun aplikasi seperti Gojek — ada data nama pengemudi, saldo dompet digital, status perjalanan, dan banyak lagi. Semua data ini perlu disimpan di suatu tempat saat program berjalan. Di sinilah variabel berperan.

Variabel adalah “kotak penyimpanan” sementara di memori komputer. Setiap kotak punya nama agar kita bisa mengaksesnya, dan punya tipe data agar Go tahu jenis isi yang boleh disimpan di dalamnya.

Go dikenal sebagai bahasa yang statically typed — artinya tipe data harus jelas sejak awal, tidak bisa berubah-ubah sembarangan. Ini membuat kode Go lebih aman dan mudah diprediksi. Jika kamu sebelumnya pernah belajar Python yang lebih fleksibel, kamu bisa membaca Menguasai Variabel dan Tipe Data Python untuk Pemula untuk membandingkan pendekatannya.

Konsep Variabel dan Cara Deklarasi di Go

Di Go, ada beberapa cara mendeklarasikan variabel. Mari kita bahas satu per satu.

1. Deklarasi Eksplisit dengan var

Cara paling formal adalah menggunakan keyword var:

package main

import "fmt"

func main() {
	// Deklarasi variabel dengan keyword var dan tipe eksplisit
	var nama string = "Budi"
	var umur int = 25
	var aktif bool = true

	// Menampilkan nilai variabel ke layar
	fmt.Println("Nama:", nama)
	fmt.Println("Umur:", umur)
	fmt.Println("Aktif:", aktif)
}

/*
# Output yang diharapkan:
# > Nama: Budi
# > Umur: 25
# > Aktif: true
*/

Kamu juga bisa mendeklarasikan tanpa langsung memberi nilai. Dalam kasus ini Go otomatis memberi zero value:

package main

import "fmt"

func main() {
	// Variabel dengan nilai awal otomatis (zero value)
	var saldo float64 // 0.0
	var kota string   // ""

	// Tampilkan nilai default ke layar
	fmt.Println("Saldo:", saldo)
	fmt.Println("Kota:", kota)
}

/*
# Output yang diharapkan:
# > Saldo: 0
# > Kota:
*/

2. Deklarasi Singkat dengan :=

Ini cara yang paling sering dipakai dalam Go — lebih ringkas dan idiomatic:

package main

import "fmt" // Mengimpor paket fmt untuk menampilkan output

func main() {
	// Deklarasi singkat: Go menyimpulkan tipe dari nilai yang diberikan
	nama := "Sari"
	umur := 22
	tinggi := 165.5

	// Menampilkan data ke layar
	fmt.Println("Nama:", nama)
	fmt.Println("Umur:", umur)
	fmt.Println("Tinggi:", tinggi)
}

/*
# Output yang diharapkan:
# > Nama: Sari
# > Umur: 22
# > Tinggi: 165.5
*/

Tanda := sekaligus mendeklarasikan variabel dan menyimpan nilainya. Go akan otomatis menyimpulkan tipe datanya dari nilai yang diberikan — fitur ini disebut type inference.

Catatan penting: := hanya bisa dipakai di dalam fungsi, bukan di level paket (luar fungsi).

3. Deklarasi Banyak Variabel Sekaligus

package main

import "fmt"

func main() {
	// Mendeklarasikan beberapa variabel dengan tipe data yang berbeda
	var (
		platform string = "KamusNgoding"
		versi    int    = 2
		aktif    bool   = true
	)

	// Deklarasi singkat untuk beberapa variabel sekaligus
	x, y, z := 10, 20, 30

	// Menampilkan nilai variabel ke layar
	fmt.Println("Platform:", platform)
	fmt.Println("Versi:", versi)
	fmt.Println("Aktif:", aktif)
	fmt.Println("Nilai x, y, z:", x, y, z)
}

/*
# Output yang diharapkan:
# > Platform: KamusNgoding
# > Versi: 2
# > Aktif: true
# > Nilai x, y, z: 10 20 30
*/

Konstanta

Jika nilainya tidak akan pernah berubah, gunakan const:

package main

import "fmt"

// Konstanta untuk nilai PI
const PI = 3.14159

// Konstanta untuk nama situs
const NAMA_SITUS = "KamusNgoding"

func main() {
	// Menampilkan nilai konstanta ke layar
	fmt.Println("Nilai PI:", PI)
	fmt.Println("Nama situs:", NAMA_SITUS)
}

/*
# Output yang diharapkan:
# > Nilai PI: 3.14159
# > Nama situs: KamusNgoding
*/

Tipe Data Dasar: Numerik, Teks, dan Boolean

Go memiliki tipe data bawaan yang terbagi menjadi beberapa kelompok. Memahami tipe-tipe ini penting agar kamu bisa memilih tipe yang tepat dan menghindari error konversi.

Tipe Numerik

Go menyediakan berbagai tipe integer dan floating-point:

package main

import "fmt"

func main() {
	// Tipe data bilangan bulat
	var a int = 100
	var b int8 = 127   // int8: -128 sampai 127
	var c int16 = 32000
	var d int32 = 2000000
	var e int64 = 9000000000

	// Tipe data bilangan bulat tanpa negatif
	var f uint = 200
	var g uint8 = 255  // uint8 juga dikenal sebagai byte

	// Tipe data desimal
	var h float32 = 3.14
	var i float64 = 3.14159265358979

	// Menampilkan semua nilai ke layar
	fmt.Println("Integer:", a, b, c, d, e)
	fmt.Println("Unsigned & Float:", f, g, h, i)
}

/*
# Output yang diharapkan:
# > Integer: 100 127 32000 2000000 9000000000
# > Unsigned & Float: 200 255 3.14 3.14159265358979
*/

Untuk kebanyakan kasus, cukup gunakan int dan float64 — keduanya adalah pilihan default yang aman.

Tipe Teks: string dan rune

package main

import "fmt"

func main() {
	// kota menyimpan teks biasa (string)
	kota := "Jakarta"

	// Menggabungkan beberapa string dengan operator +
	sapaan := "Halo, " + kota + "!"

	// String multi-baris ditulis dengan backtick
	deskripsi := `Go adalah bahasa pemrograman
yang dikembangkan oleh Google.
Cocok untuk membangun server dan API.`

	// Rune menyimpan satu karakter Unicode
	huruf := 'A'

	// Menampilkan isi variabel ke layar
	fmt.Println(sapaan)
	fmt.Println(deskripsi)

	// %c untuk karakter, %d untuk kode angkanya
	fmt.Printf("Huruf: %c, kode ASCII: %d\n", huruf, huruf)
}

/*
# Output yang diharapkan:
# > Halo, Jakarta!
# > Go adalah bahasa pemrograman
# > yang dikembangkan oleh Google.
# > Cocok untuk membangun server dan API.
# > Huruf: A, kode ASCII: 65
*/

Tipe Boolean

package main

import "fmt"

func main() {
	// Menyimpan status login pengguna
	isLogin := true

	// Menyimpan status premium pengguna
	isPremium := false

	// Menampilkan nilai masing-masing variabel
	fmt.Println("Login:", isLogin)
	fmt.Println("Premium:", isPremium)

	// Pengguna hanya bisa akses konten jika login dan premium
	fmt.Println("Bisa akses konten:", isLogin && isPremium)
}

/*
# Output yang diharapkan:
# > Login: true
# > Premium: false
# > Bisa akses konten: false
*/

Boolean hanya punya dua nilai: true atau false. Sering dipakai untuk kondisi logika, seperti mengecek apakah pengguna sudah login.

Konversi Tipe Data dan Zero Value

Zero Value

Salah satu fitur menarik Go adalah zero value — setiap variabel yang dideklarasikan tanpa nilai awal otomatis mendapat nilai default:

package main

import "fmt"

func main() {
	// Variabel dideklarasikan tanpa nilai awal.
	// Go akan memberi nilai default (zero value) secara otomatis.
	var angka int
	var teks string
	var aktif bool

	// Tampilkan nilai default dari masing-masing variabel.
	fmt.Printf("angka: %d\n", angka)
	fmt.Printf("teks: '%s'\n", teks)
	fmt.Printf("aktif: %t\n", aktif)
}

/*
# Output yang diharapkan:
# > angka: 0
# > teks: ''
# > aktif: false
*/

Ini berbeda dengan banyak bahasa lain yang membiarkan variabel tidak terinitialisasi, yang bisa menyebabkan bug tak terduga.

Konversi Tipe Data

Go tidak melakukan konversi otomatis antar tipe numerik. Kamu harus melakukannya secara eksplisit:

package main

import "fmt"

func main() {
	// harga bertipe int
	harga := 15000

	// diskon bertipe float64 (10%)
	diskon := 0.1

	// Go tidak bisa langsung mengalikan int dengan float64
	// total := harga * diskon // ini akan error

	// Konversi harga ke float64 agar tipenya sama
	totalDiskon := float64(harga) * diskon
	fmt.Printf("Diskon: Rp %.2f\n", totalDiskon)

	// Contoh konversi float64 ke int
	nilaiFloat := 99.9

	// Saat diubah ke int, bagian desimal dipotong, bukan dibulatkan
	nilaiInt := int(nilaiFloat)
	fmt.Println("Nilai int:", nilaiInt)
}

/*
# Output yang diharapkan:
# > Diskon: Rp 1500.00
# > Nilai int: 99
*/

Hal yang sama berlaku antara int dan string. Untuk konversi string, gunakan paket strconv:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// Ubah nilai integer menjadi string
	angka := 42
	teks := strconv.Itoa(angka)

	// Tampilkan hasil konversi int ke string
	fmt.Println("Tipe data string:", teks)
	fmt.Println("Gabungan teks:", teks+" tahun")

	// Data string yang berisi angka
	inputUser := "2024"

	// Ubah string menjadi integer
	tahun, err := strconv.Atoi(inputUser)
	if err != nil {
		// Jika input bukan angka, tampilkan pesan error
		fmt.Println("Input bukan angka!")
		return
	}

	// Tampilkan hasil setelah nilainya ditambah 1
	fmt.Println("Tahun + 1:", tahun+1)
}

/*
# Output yang diharapkan:
# > Tipe data string: 42
# > Gabungan teks: 42 tahun
# > Tahun + 1: 2025
*/

Pola nilai, err := ... adalah idiom khas Go untuk menangani error — ini akan sering kamu temui. Konsep serupa soal penanganan tipe secara ketat juga dibahas di Tipe Data Dasar di TypeScript, jika kamu ingin membandingkan pendekatannya.

Contoh Kasus Nyata: Membuat Program Biodata Sederhana

Mari kita gabungkan semua konsep di atas dalam satu program yang utuh:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// Menyimpan data biodata ke dalam variabel
	nama := "Rizki Pratama"
	umur := 28
	kota := "Bandung"
	tinggi := 172.5
	isPremium := false

	// Menampilkan judul
	fmt.Println("========== BIODATA ==========")

	// Menampilkan isi biodata
	fmt.Println("Nama    :", nama)
	fmt.Println("Umur    :", umur, "tahun")
	fmt.Println("Kota    :", kota)
	fmt.Printf("Tinggi  : %.1f cm\n", tinggi)
	fmt.Println("Premium :", isPremium)

	// Mengubah umur dari angka menjadi teks
	umurTeks := strconv.Itoa(umur)

	// Menggabungkan beberapa data menjadi satu kalimat
	pesan := nama + " berusia " + umurTeks + " tahun, tinggal di " + kota + "."
	fmt.Println()
	fmt.Println("Keterangan:", pesan)

	// Menghitung perkiraan tahun lahir
	const tahunSekarang = 2026
	tahunLahir := tahunSekarang - umur
	fmt.Println("Tahun lahir perkiraan:", tahunLahir)
}

/*
# Output yang diharapkan:
# > ========== BIODATA ==========
# > Nama    : Rizki Pratama
# > Umur    : 28 tahun
# > Kota    : Bandung
# > Tinggi  : 172.5 cm
# > Premium : false
# >
# > Keterangan: Rizki Pratama berusia 28 tahun, tinggal di Bandung.
# > Tahun lahir perkiraan: 1998
*/

Bayangkan jika kamu ingin membangun fitur profil pengguna seperti di aplikasi Tokopedia — data seperti nama, kota, dan status premium adalah contoh nyata variabel yang akan kamu gunakan setiap hari.

Pertanyaan yang Sering Diajukan

Apa perbedaan var dan := di Go?

Keduanya digunakan untuk mendeklarasikan variabel, tapi dengan cara berbeda. var bisa digunakan di luar maupun di dalam fungsi, dan memungkinkan deklarasi tanpa nilai awal (variabel akan mendapatkan zero value). := hanya bisa dipakai di dalam fungsi dan secara otomatis menentukan tipe variabel berdasarkan nilai yang diberikan.

Apakah Go memiliki tipe data null seperti di bahasa lain?

Go tidak mengenal null seperti di JavaScript atau Python. Sebagai gantinya, Go menggunakan nilai nil yang hanya berlaku untuk tipe tertentu seperti pointer, slice, map, channel, dan interface. Untuk tipe data dasar seperti int, string, dan bool, Go menggunakan zero value sehingga tidak pernah ada kondisi “nilai tidak ada”.

Kapan sebaiknya menggunakan int biasa dibanding int32 atau int64?

Gunakan int untuk kebutuhan umum seperti penghitung loop atau indeks array — ukurannya otomatis menyesuaikan platform (32-bit atau 64-bit) sehingga performa optimal. Gunakan int32 atau int64 hanya jika kamu perlu kompatibilitas lintas platform atau bekerja dengan protokol jaringan dan format file yang mensyaratkan ukuran bit tertentu.

Mengapa Go tidak melakukan konversi tipe secara otomatis?

Konversi tipe otomatis (implicit conversion) bisa menyebabkan bug yang sulit dilacak, seperti kehilangan presisi saat float diubah ke int atau overflow pada tipe yang lebih kecil. Dengan memaksa konversi eksplisit, Go memastikan programmer sadar penuh atas perubahan tipe yang terjadi, sehingga kode lebih aman dan mudah diprediksi.

Kesimpulan

Variabel dan tipe data adalah fondasi dari semua program Go yang akan kamu tulis. Beberapa poin penting yang perlu diingat:

• Gunakan := untuk deklarasi cepat di dalam fungsi, dan var jika butuh kontrol lebih atau deklarasi di level paket.
• Go adalah bahasa statically typed — tipe data harus jelas dan tidak bisa berubah setelah dideklarasikan.
• Tipe data dasar Go meliputi int, float64, string, bool, dan rune — masing-masing untuk kebutuhan yang berbeda.
• Konversi tipe harus dilakukan secara eksplisit — Go tidak akan melakukannya secara otomatis.
• Setiap variabel yang tidak diberi nilai awal mendapat zero value yang aman.
• Gunakan const untuk nilai yang tidak akan pernah berubah.

Dengan pemahaman ini, kamu sudah siap untuk melangkah ke topik berikutnya seperti percabangan, perulangan, dan fungsi di Go. Konsep variabel yang kamu pelajari hari ini akan terus dipakai di setiap baris kode yang kamu tulis ke depannya.