Variabel, Tipe,
dan Zero Value

Dari fleksibilitas JavaScript menuju kontrak eksplisit Go

Kamu sudah mengenal TypeScript sebagai lapisan tipe di atas JavaScript, tetapi Go membawa tipe turun ke level bahasa dan compiler, bukan sekadar bantuan saat menulis kode.

Di JavaScript, sebuah nilai bisa berganti tipe saat program berjalan. Di TypeScript, tipe membantu saat development, tetapi hasil akhirnya tetap JavaScript yang dieksekusi runtime. Di Go, tipe adalah bagian dari bahasa yang diperiksa compiler sebelum program berjalan, sehingga banyak bug ketahuan lebih awal, terutama di backend yang berurusan dengan harga, stok, status produk, dan payload API.

Ada satu perbedaan halus yang penting untuk pembaca dari TypeScript. TypeScript memakai structural typing, jadi dua tipe dengan bentuk sama dianggap kompatibel. Go memakai named typing, jadi type ProductStatus string adalah tipe yang benar-benar baru dan tidak otomatis bisa dipertukarkan dengan string. Konsekuensi ini akan terasa jelas saat kita membahas custom type.

Modul ini tidak mengajari variabel dari nol. Fokusnya adalah cara berpikir Go saat kamu memodelkan data backend online shop skincare, lewat var dan :=, const, tipe dasar, zero value, konversi tipe, custom type, dan type alias.

Dokumentasi resmi yang relevan: Go Specification, A Tour of Go: Basic types, A Tour of Go: Zero values, Constants (Go Blog), dan Go Modules Reference.

Dua cara deklarasi, dua konteks penggunaan

Go punya var untuk deklarasi yang bisa eksplisit dan := untuk deklarasi ringkas di dalam fungsi.

Di JavaScript kamu terbiasa memakai let dan const. Di Go, pilihan paling sering adalah var atau short declaration :=. Keduanya membuat variabel, tetapi aturan tempat pakainya berbeda, dan perbedaan itulah yang sering membuat pendatang baru tersandung.

Tiga bentuk deklarasi yang perlu kamu kenal

Go memberi tiga cara menulis variabel: eksplisit dengan tipe, var dengan inferensi, dan short declaration. Ketiganya menghasilkan variabel, hanya beda gaya dan tempat.

cmd/playground/declare.goSalin
package main

import "fmt"

func main() {
	var price int = 129000 // var eksplisit dengan tipe
	var stock = 12         // var dengan inferensi tipe (int)
	name := "Niacinamide Serum" // short declaration, hanya di dalam fungsi

	fmt.Println(price, stock, name)
}

Aturan praktis

Gunakan var saat kamu butuh deklarasi di level package, ingin menulis tipe secara jelas, atau sengaja memanfaatkan zero value. Gunakan := untuk nilai lokal di dalam fungsi saat tipenya sudah jelas dari sisi kanan.

flowchart TD
  A["Mau mendeklarasikan variabel"] --> B{"Di dalam fungsi?"}
  B -->|"Tidak, level package"| C["Pakai var, const, type, atau func"]
  B -->|"Ya, di dalam fungsi"| D{"Tipe jelas dari sisi kanan?"}
  D -->|"Ya, ingin ringkas"| E["Pakai short declaration :="]
  D -->|"Butuh tipe eksplisit atau zero value"| F["Pakai var"]

Gambar 1. var bisa dipakai di mana saja, sedangkan := hanya hidup di dalam fungsi. Saat ragu di level package, jawabannya selalu var, const, type, atau func.

cmd/playground/main.goSalin
package main

import "fmt"

var appName string = "skincare-backend"
var maxFeaturedProducts int

func main() {
	storeName := "GlowLab"
	isActive := true

	fmt.Println(appName)
	fmt.Println(storeName)
	fmt.Println(isActive)
	fmt.Println(maxFeaturedProducts)
}

Perhatikan maxFeaturedProducts tidak diberi nilai awal, tetapi Go tetap memberinya nilai aman, yaitu 0 untuk int. Kita bahas lebih dalam di section zero value.

cmd/playground/invalid.goSalin
package main

productName := "Hydrating Toner" // tidak valid di level package

func main() {}

contoh error compilerSalin
syntax error: non-declaration statement outside function body

Short declaration harus memperkenalkan minimal satu nama baru

Di Go, := bukan operator update. Ia mendeklarasikan variabel baru. Bila semua nama di sisi kiri sudah ada dalam scope yang sama, compiler menolak. Namun bila ada minimal satu nama baru, := boleh dipakai walau sebagian nama lama ikut ditugasi ulang.

cmd/playground/redeclare.goSalin
package main

import "fmt"

func main() {
	quantity := 2
	quantity = 3 // assignment biasa, bukan deklarasi

	productName, quantity := "Serum", 4 // valid: productName nama baru

	fmt.Println(productName, quantity)
}

Baris productName, quantity := "Serum", 4 valid karena productName adalah nama baru, walaupun quantity sudah ada. Pola ini sering muncul saat fungsi mengembalikan dua nilai, misalnya result, err := doSomething(), lalu err dipakai ulang di pemanggilan berikutnya.

Konstanta Go bukan object freeze ala JavaScript

const di Go menyimpan nilai konstan untuk angka, string, rune, dan boolean, bukan object, slice, atau map.

Di JavaScript, const berarti binding tidak bisa diarahkan ke nilai lain, tetapi object atau array di dalamnya tetap bisa dimutasi. Di Go, const adalah nilai yang sudah pasti pada compile-time untuk jenis nilai tertentu, jadi kamu tidak membuat konstanta slice, map, struct, atau objek kompleks.

internal/product/constants.goSalin
package product

const DefaultPageSize = 20
const MaxPageSize = 100
const CurrencyCode = "IDR"
const IsCatalogPublic = true

Tipe dasar yang akan sering kamu pakai di awal proyek skincare adalah string, int, int64, float64, dan bool.

internal/product/basic_types.goSalin
package product

type Product struct {
	ID          int64
	Name        string
	PriceRupiah int64
	Quantity    int
	IsActive    bool
}

Konstanta typed dan untyped

Ini bagian yang sering membingungkan, padahal sangat berguna. Konstanta tanpa tipe eksplisit, seperti const DefaultPageSize = 20, disebut untyped constant. Ia punya default type (di sini int), tetapi bisa menyesuaikan diri ke konteks numeric lain tanpa konversi manual selama nilainya muat.

cmd/playground/const_kind.goSalin
package main

import "fmt"

const DefaultPageSize = 20  // untyped int constant
const MaxPageSize int = 100 // typed: selalu int

func main() {
	var limit int = DefaultPageSize     // ok
	var ratio float64 = DefaultPageSize // ok juga, untyped menyesuaikan ke float64

	// var bad float64 = MaxPageSize     // ERROR: butuh float64(MaxPageSize)
	var ok float64 = float64(MaxPageSize)

	fmt.Println(limit, ratio, ok)
}

Karena DefaultPageSize untyped, ia bisa langsung dipakai sebagai int maupun float64. Sebaliknya MaxPageSize sudah typed int, jadi memakainya sebagai float64 butuh konversi eksplisit. Aturan sederhananya: biarkan konstanta untyped kecuali kamu memang ingin mengunci tipenya.

Konsep penting yang tidak punya padanan langsung di JavaScript

Di Go, variabel yang dideklarasikan tanpa nilai selalu mendapat nilai awal sesuai tipenya, jadi tidak pernah ada keadaan undefined.

Di JavaScript, variabel yang belum diisi bernilai undefined. Di Go tidak ada undefined. Numeric menjadi 0, string menjadi string kosong, bool menjadi false, sedangkan pointer, slice, dan map menjadi nil.

cmd/playground/zero_value.goSalin
package main

import "fmt"

func main() {
	var quantity int
	var productName string
	var price float64
	var isActive bool
	var note *string

	fmt.Printf("quantity: %d\n", quantity)
	fmt.Printf("productName: %q\n", productName)
	fmt.Printf("price: %.2f\n", price)
	fmt.Printf("isActive: %t\n", isActive)
	fmt.Printf("note is nil: %t\n", note == nil)
}

outputSalin
quantity: 0
productName: ""
price: 0.00
isActive: false
note is nil: true

flowchart LR
  A["Deklarasi tanpa nilai awal"] --> B{"Tipe variabel"}
  B -->|"int, int64, float64"| C["0"]
  B -->|"string"| D["string kosong"]
  B -->|"bool"| E["false"]
  B -->|"pointer, slice, map"| F["nil"]
  C --> G["Variabel langsung valid, bukan undefined"]
  D --> G
  E --> G
  F --> G

Gambar 2. Zero value membuat setiap variabel Go punya nilai awal yang valid menurut tipenya, sehingga tidak ada keadaan undefined seperti di JavaScript.

Zero value juga berlaku untuk struct. Sebuah Product{} kosong langsung bisa dipakai, dan setiap field-nya terisi zero value masing-masing.

cmd/playground/zero_struct.goSalin
package main

import "fmt"

type Product struct {
	ID          int64
	Name        string
	PriceRupiah int64
	IsActive    bool
}

func main() {
	var p Product // semua field zero value
	fmt.Printf("%+v\n", p)
	// {ID:0 Name: PriceRupiah:0 IsActive:false}
}

internal/cart/validation.goSalin
package cart

import "errors"

var ErrInvalidQuantity = errors.New("quantity must be greater than zero")

func ValidateQuantity(quantity int) error {
	if quantity <= 0 {
		return ErrInvalidQuantity
	}

	return nil
}

Tidak ada implicit coercion seperti JavaScript

Go tidak mengubah tipe numeric secara diam-diam. Setiap perpindahan tipe harus kamu tulis eksplisit, agar pembaca dan compiler sama-sama sadar.

JavaScript sangat permisif. Ekspresi "10" + 2 menghasilkan string, sementara "10" - 2 menghasilkan angka. Di backend, perilaku seperti ini berbahaya karena nilai dari request, database, dan kalkulasi bisnis bisa tercampur tanpa sadar. Go memilih pendekatan eksplisit: int, int64, dan float64 adalah tipe berbeda, dan kamu harus mengubahnya secara sadar.

flowchart LR
  A["Nilai bertipe int"] -->|"butuh float64(x)"| B["Nilai bertipe float64"]
  B -->|"butuh int64(y)"| A
  C["int * float64 tanpa konversi"] --> D["compile error: mismatched types"]

Gambar 3. int dan float64 adalah dua pulau tipe terpisah. Satu-satunya jembatan adalah konversi eksplisit; operasi langsung antar pulau ditolak compiler.

Contoh nyata di toko skincare adalah menghitung rating rata-rata. Total bintang dan jumlah review keduanya int, tetapi hasilnya harus pecahan, jadi kita konversi dulu.

cmd/playground/rating.goSalin
package main

import "fmt"

func main() {
	totalStars := 22
	reviewCount := 5

	naive := totalStars / reviewCount               // 4, pembagian int membuang sisa
	avg := float64(totalStars) / float64(reviewCount) // 4.4

	fmt.Println(naive)
	fmt.Printf("%.1f\n", avg)
}

Kode berikut tidak valid karena reviewCount bertipe int, sedangkan avgRating bertipe float64.

cmd/playground/invalid_conversion.goSalin
package main

func main() {
	reviewCount := 5
	avgRating := 4.4

	_ = reviewCount * avgRating // tidak valid
}

contoh error compilerSalin
invalid operation: reviewCount * avgRating (mismatched types int and float64)

Harga tetap int64, konversi hanya untuk hitung persen

Karena uang disimpan int64, perhitungan diskon persen harus mampir sebentar ke float64, lalu kembali ke int64. Di sinilah konversi eksplisit benar-benar terpakai di domain.

internal/pricing/discount.goSalin
package pricing

import "math"

// ApplyPercentDiscount memotong harga (rupiah) sebesar persen tertentu.
// Uang tetap int64; float64 hanya dipakai sesaat untuk hitung persen, lalu dibulatkan.
func ApplyPercentDiscount(priceRupiah int64, percent float64) int64 {
	discounted := float64(priceRupiah) * (1 - percent/100)
	return int64(math.Round(discounted))
}

Konversi numeric ke string butuh package khusus

Untuk mengubah angka menjadi teks tampilan, pakai package strconv atau fmt. Jangan memakai string(65) untuk membuat teks angka, karena itu mengubah kode karakter menjadi rune.

cmd/playground/strconv.goSalin
package main

import (
	"fmt"
	"strconv"
)

func main() {
	productID := int64(42)
	quantity := 3

	idText := strconv.FormatInt(productID, 10)
	qtyText := strconv.Itoa(quantity)

	bad := string(65) // "A", bukan "65": go vet akan memperingatkan ini

	fmt.Println(idText, qtyText, bad)
}

Membedakan domain type dari sekadar tipe bawaan

Go memungkinkan kamu membuat tipe baru agar aturan domain lebih ekspresif dan lebih sulit tertukar.

Custom type dibuat dengan bentuk type Nama TipeDasar. Hasilnya tipe baru yang berbeda dari tipe dasarnya, walaupun representasi nilainya sama. Alias dibuat dengan bentuk type Nama = TipeDasar, dengan tanda sama dengan, dan ia hanya nama lain untuk tipe yang persis sama.

flowchart TB
  subgraph c["type ProductStatus string  (custom type)"]
    A["ProductStatus"] -->|"tipe BARU, beda dari string"| B["butuh konversi: ProductStatus(s) atau string(ps)"]
  end
  subgraph al["type UserID = int64  (alias)"]
    C["UserID"] -->|"nama lain, tipe SAMA"| D["bebas dipertukarkan dengan int64"]
  end

Gambar 4. Tanpa tanda sama dengan, type membuat tipe baru yang butuh konversi. Dengan tanda sama dengan, type hanya memberi nama lain untuk tipe yang sama.

internal/product/status.goSalin
package product

type ProductStatus string

const (
	ProductStatusDraft      ProductStatus = "draft"
	ProductStatusActive     ProductStatus = "active"
	ProductStatusArchived   ProductStatus = "archived"
	ProductStatusOutOfStock ProductStatus = "out_of_stock"
)

func (s ProductStatus) IsSellable() bool {
	return s == ProductStatusActive
}

Custom type seperti ProductStatus membuat kode domain lebih jelas. Fungsi yang menerima ProductStatus tidak bisa sembarangan diberi string lain tanpa konversi eksplisit, sehingga status acak tidak gampang menyelinap masuk.

internal/product/check.goSalin
package product

func CanShowInCatalog(status ProductStatus, isActive bool) bool {
	return isActive && status.IsSellable()
}

Enum rapi dengan iota

Saat status tidak perlu disimpan sebagai teks, iota memberi cara ringkas membuat enum integer berurutan. Cocok untuk konsep berjenjang seperti tier membership pelanggan.

internal/customer/tier.goSalin
package customer

type MembershipTier int

const (
	TierBronze   MembershipTier = iota // 0
	TierSilver                         // 1
	TierGold                           // 2
	TierPlatinum                       // 3
)

func (t MembershipTier) FreeShipping() bool {
	return t >= TierGold
}

Type alias dan kapan memakainya

Alias tidak membuat tipe baru. Ia berguna saat kamu ingin memberi nama domain tanpa mengubah kompatibilitas tipe dasar, atau saat memindahkan tipe antar package secara bertahap tanpa memecah kode lama sekaligus.

internal/identity/types.goSalin
package identity

type UserID = int64

Dari tipe dasar menuju model produk yang nyata

Sekarang kita rangkai semua yang dipelajari menjadi model produk skincare yang sederhana tetapi aman.

Untuk online shop skincare, data produk minimal punya ID, nama, harga, stok, status, dan flag aktif. Kita mulai dari model ringan. Nanti, saat masuk roadmap domain dan database, model ini dipisah lebih rapi sesuai layer.

internal/product/status.goSalin
package product

type ProductStatus string

const (
	ProductStatusDraft      ProductStatus = "draft"
	ProductStatusActive     ProductStatus = "active"
	ProductStatusArchived   ProductStatus = "archived"
	ProductStatusOutOfStock ProductStatus = "out_of_stock"
)

func (s ProductStatus) IsSellable() bool {
	return s == ProductStatusActive
}

internal/product/product.goSalin
package product

type Product struct {
	ID          int64
	Name        string
	PriceRupiah int64
	Quantity    int
	Status      ProductStatus
	IsActive    bool
}

func (p Product) IsAvailable() bool {
	return p.IsActive && p.Quantity > 0 && p.Status.IsSellable()
}

classDiagram
  class Product {
    +int64 ID
    +string Name
    +int64 PriceRupiah
    +int Quantity
    +ProductStatus Status
    +bool IsActive
    +IsAvailable() bool
  }
  class ProductStatus {
    <<string>>
    +IsSellable() bool
  }
  Product --> ProductStatus : Status

Gambar 5. Semua konsep modul ini berkumpul: tipe dasar untuk field, custom type ProductStatus dengan method-nya sendiri, dan int64 untuk harga agar uang tetap presisi.

cmd/playground/main.goSalin
package main

import (
	"fmt"

	"github.com/kamu/skincare-backend/internal/product"
)

func main() {
	serum := product.Product{
		ID:          1001,
		Name:        "Niacinamide Serum",
		PriceRupiah: 129000,
		Quantity:    12,
		Status:      product.ProductStatusActive,
		IsActive:    true,
	}

	fmt.Println(serum.Name)
	fmt.Println(serum.IsAvailable())
}

Latihan kecil untuk menempelkan kebiasaan tipe eksplisit

Latihan ini membuat kamu merasakan langsung bedanya deklarasi, zero value, konversi, dan custom type dalam satu project kecil.

TerminalSalin
mkdir -p cmd/playground internal/product
go run ./cmd/playground

Tambahkan fungsi kecil untuk menghitung subtotal. Karena harga int64, konversi yang terpaksa kita lakukan adalah pada quantity, bukan pada uangnya.

internal/product/pricing.goSalin
package product

func CalculateSubtotal(priceRupiah int64, quantity int) int64 {
	return priceRupiah * int64(quantity)
}

Lalu panggil dari main.go.

cmd/playground/main.goSalin
package main

import (
	"fmt"

	"github.com/kamu/skincare-backend/internal/product"
)

func main() {
	serum := product.Product{
		ID:          1001,
		Name:        "Niacinamide Serum",
		PriceRupiah: 129000,
		Quantity:    2,
		Status:      product.ProductStatusActive,
		IsActive:    true,
	}

	subtotal := product.CalculateSubtotal(serum.PriceRupiah, serum.Quantity)

	fmt.Println(serum.Name)
	fmt.Println(serum.IsAvailable())
	fmt.Println(subtotal) // 258000
}

Kesalahan kecil yang sering muncul saat pindah ke Go

Sebagian besar bug awal di Go muncul karena membawa kebiasaan bahasa dinamis ke bahasa yang lebih eksplisit.

cmd/playground/shadowing.goSalin
package main

import "fmt"

func main() {
	status := "active"

	if true {
		status := "draft" // variabel BARU, hanya hidup di dalam blok ini
		fmt.Println(status)
	}

	fmt.Println(status) // status luar tidak berubah
}

outputSalin
draft
active

Contoh di atas benar secara sintaks, tetapi bisa menyesatkan. Di service layer nanti, shadowing seperti ini bisa membuat hasil validasi atau assignment terlihat benar padahal nilai di luar blok tidak pernah berubah.

Variabel dan tipe adalah fondasi kecil yang menentukan seberapa aman model domain kita saat proyek membesar.

Pemetaan ke proyek online shop skincare