BAB 8: Konstanta

Setelah mempelajari variable dan data types, sekarang kita akan belajar tentang konstanta. Konstanta adalah nilai yang tidak berubah sepanjang program berjalan. Berbeda dengan variable yang nilainya bisa diubah-ubah, konstanta nilainya tetap dari awal sampai akhir program.

Apa itu Konstanta?

Konstanta adalah jenis variable yang nilainya tidak bisa diubah setelah dideklarasikan. Bayangkan konstanta seperti nama kamu - sekali ditentukan, ya tetap begitu. Konstanta sangat berguna untuk menyimpan nilai-nilai yang memang tidak akan berubah, seperti nilai pi (3.14159), kecepatan cahaya, atau konfigurasi aplikasi.

Perbedaan utama konstanta dengan variable:

• Variable: nilainya bisa berubah (var)
• Konstanta: nilainya tetap selamanya (const)

Deklarasi Konstanta Dasar

Cara mendeklarasikan konstanta sama seperti variable, tapi menggunakan keyword const:

package main

import "fmt"

func main() {
    const firstName string = "John"
    const pi float64 = 3.14159
    const isActive bool = true
    
    fmt.Println("Nama:", firstName)
    fmt.Println("Pi:", pi)
    fmt.Println("Status:", isActive)
}

Type Inference pada Konstanta

Sama seperti variable, konstanta juga mendukung type inference - Go bisa menebak type data berdasarkan nilai yang diberikan:

package main

import "fmt"

func main() {
    const lastName = "Wick"           // string
    const gravity = 9.81              // float64
    const maxUsers = 100              // int
    const isReady = true              // bool
    
    fmt.Printf("lastName: %s (type: %T)\n", lastName, lastName)
    fmt.Printf("gravity: %.2f (type: %T)\n", gravity, gravity)
    fmt.Printf("maxUsers: %d (type: %T)\n", maxUsers, maxUsers)
    fmt.Printf("isReady: %t (type: %T)\n", isReady, isReady)
}

Deklarasi Multiple Konstanta

Konstanta dalam Satu Baris

package main

import "fmt"

func main() {
    const satu, dua = 1, 2
    const three, four string = "tiga", "empat"
    
    fmt.Println("satu:", satu, "dua:", dua)
    fmt.Println("three:", three, "four:", four)
}

Grouped Constants

Untuk organisasi yang lebih baik, kita bisa mengelompokkan konstanta menggunakan kurung:

package main

import "fmt"

func main() {
    const (
        square     = "kotak"
        isToday    bool = true
        numeric    uint8 = 1
        floatNum   = 2.2
    )
    
    fmt.Println("Shape:", square)
    fmt.Println("Today:", isToday)
    fmt.Println("Number:", numeric)
    fmt.Println("Float:", floatNum)
}

Konstanta dengan Nilai yang Sama

Ketika kita tidak menuliskan nilai dalam deklarasi konstanta, Go akan menggunakan nilai yang sama dengan konstanta di atasnya:

package main

import "fmt"

func main() {
    const (
        a = "konstanta"
        b                    // b akan sama dengan a: "konstanta"
        c = "berbeda"
        d                    // d akan sama dengan c: "berbeda"
    )
    
    fmt.Println("a:", a)     // konstanta
    fmt.Println("b:", b)     // konstanta
    fmt.Println("c:", c)     // berbeda
    fmt.Println("d:", d)     // berbeda
}

Kombinasi Berbagai Deklarasi

package main

import "fmt"

func main() {
    const (
        today string = "senin"
        sekarang               // "senin" (sama dengan today)
        isToday2 = true        // type inference untuk bool
        tomorrow               // true (sama dengan isToday2)
    )
    
    fmt.Println("today:", today)
    fmt.Println("sekarang:", sekarang)
    fmt.Println("isToday2:", isToday2)
    fmt.Println("tomorrow:", tomorrow)
}

Konstanta untuk Konfigurasi Aplikasi

Konstanta sangat berguna untuk menyimpan konfigurasi aplikasi:

package main

import "fmt"

const (
    AppName    = "My Go App"
    Version    = "1.0.0"
    MaxUsers   = 1000
    TimeoutSec = 30
    DebugMode  = true
)

func main() {
    fmt.Printf("Starting %s v%s\n", AppName, Version)
    fmt.Printf("Max users: %d\n", MaxUsers)
    fmt.Printf("Timeout: %d seconds\n", TimeoutSec)
    fmt.Printf("Debug mode: %t\n", DebugMode)
}

Konstanta Matematika

package main

import "fmt"

const (
    Pi         = 3.14159265359
    E          = 2.71828182846
    GoldenRatio = 1.61803398875
    SqrtTwo    = 1.41421356237
)

func calculateCircleArea(radius float64) float64 {
    return Pi * radius * radius
}

func main() {
    radius := 5.0
    area := calculateCircleArea(radius)
    
    fmt.Printf("Circle area with radius %.1f: %.2f\n", radius, area)
    fmt.Printf("Pi: %.5f\n", Pi)
    fmt.Printf("Euler's number: %.5f\n", E)
}

Konstanta String untuk Enum-like Values

Meskipun Go tidak memiliki enum seperti bahasa lain, kita bisa menggunakan konstanta string untuk hal serupa:

package main

import "fmt"

const (
    StatusPending   = "pending"
    StatusApproved  = "approved"
    StatusRejected  = "rejected"
    StatusCompleted = "completed"
)

func processOrder(status string) {
    switch status {
    case StatusPending:
        fmt.Println("Order is waiting for approval")
    case StatusApproved:
        fmt.Println("Order has been approved")
    case StatusRejected:
        fmt.Println("Order has been rejected")
    case StatusCompleted:
        fmt.Println("Order has been completed")
    default:
        fmt.Println("Unknown status")
    }
}

func main() {
    processOrder(StatusPending)
    processOrder(StatusApproved)
    processOrder("invalid")
}

Konstanta vs Variable

Mari lihat perbedaan praktis antara konstanta dan variable:

package main

import "fmt"

func main() {
    // Variable - bisa diubah
    var name string = "John"
    fmt.Println("Original name:", name)
    
    name = "Jane"  // OK - variable bisa diubah
    fmt.Println("Updated name:", name)
    
    // Konstanta - tidak bisa diubah
    const companyName = "Tech Corp"
    fmt.Println("Company:", companyName)
    
    // companyName = "New Corp"  // ERROR! Konstanta tidak bisa diubah
    
    // Konstanta harus diinisialisasi saat deklarasi
    // const uninitialized  // ERROR! Konstanta harus ada nilainya
}

Scope Konstanta

Konstanta mengikuti aturan scope yang sama dengan variable:

package main

import "fmt"

// Global constants
const (
    GlobalAppName = "My App"
    GlobalVersion = "1.0"
)

func processData() {
    // Local constants
    const (
        ProcessTimeout = 30
        MaxRetries     = 3
    )
    
    fmt.Printf("Processing with timeout: %d seconds\n", ProcessTimeout)
    fmt.Printf("Max retries: %d\n", MaxRetries)
    fmt.Printf("App: %s v%s\n", GlobalAppName, GlobalVersion)
}

func main() {
    processData()
    
    // Konstanta dalam block
    if true {
        const localMessage = "Hello from block"
        fmt.Println(localMessage)
    }
    
    // fmt.Println(localMessage)  // ERROR! localMessage tidak ada di scope ini
}

Konstanta untuk HTTP Status Codes

Contoh praktis penggunaan konstanta untuk HTTP status codes:

package main

import "fmt"

const (
    StatusOK                   = 200
    StatusBadRequest          = 400
    StatusUnauthorized        = 401
    StatusForbidden           = 403
    StatusNotFound            = 404
    StatusInternalServerError = 500
)

func handleResponse(statusCode int) {
    switch statusCode {
    case StatusOK:
        fmt.Println("Request successful")
    case StatusBadRequest:
        fmt.Println("Bad request")
    case StatusUnauthorized:
        fmt.Println("Authentication required")
    case StatusNotFound:
        fmt.Println("Resource not found")
    case StatusInternalServerError:
        fmt.Println("Server error")
    default:
        fmt.Printf("Status code: %d\n", statusCode)
    }
}

func main() {
    handleResponse(StatusOK)
    handleResponse(StatusNotFound)
    handleResponse(StatusInternalServerError)
}

Konstanta untuk Database Configuration

package main

import "fmt"

const (
    // Database constants
    DBHost     = "localhost"
    DBPort     = 5432
    DBName     = "myapp_db"
    DBUser     = "admin"
    DBPassword = "secret123"
    
    // Connection pool constants
    MaxOpenConns    = 25
    MaxIdleConns    = 25
    ConnMaxLifetime = 300 // seconds
)

func createConnectionString() string {
    return fmt.Sprintf("host=%s port=%d dbname=%s user=%s password=%s",
        DBHost, DBPort, DBName, DBUser, DBPassword)
}

func main() {
    connStr := createConnectionString()
    fmt.Println("Connection string:", connStr)
    fmt.Printf("Max connections: %d\n", MaxOpenConns)
    fmt.Printf("Max idle connections: %d\n", MaxIdleConns)
}

Konstanta dalam Package Level

Konstanta juga bisa dideklarasikan di level package (di luar function):

package main

import "fmt"

// Package level constants
const (
    AppTitle       = "My Golang Application"
    DefaultTimeout = 30
    MaxFileSize    = 1024 * 1024 * 10 // 10MB
)

func uploadFile(size int) {
    if size > MaxFileSize {
        fmt.Printf("File too large. Max size: %d bytes\n", MaxFileSize)
        return
    }
    fmt.Printf("Uploading file of size: %d bytes\n", size)
}

func main() {
    fmt.Printf("Welcome to %s\n", AppTitle)
    fmt.Printf("Default timeout: %d seconds\n", DefaultTimeout)
    
    uploadFile(1024)           // OK
    uploadFile(MaxFileSize + 1) // Too large
}

Best Practices

1. Gunakan Nama yang Deskriptif

// BAIK
const (
    MaxRetryAttempts = 3
    ConnectionTimeout = 30
    DefaultPageSize = 20
)

// KURANG BAIK
const (
    M = 3
    T = 30
    P = 20
)

2. Kelompokkan Konstanta yang Berkaitan

// BAIK: kelompokkan berdasarkan kategori
const (
    // HTTP Status Codes
    StatusOK = 200
    StatusNotFound = 404
    StatusError = 500
)

const (
    // Database Configuration
    DBTimeout = 30
    DBMaxConns = 10
    DBRetries = 3
)

// KURANG BAIK: semua dicampur
const (
    StatusOK = 200
    DBTimeout = 30
    StatusNotFound = 404
    DBMaxConns = 10
)

3. Gunakan Konstanta untuk Magic Numbers

// BAIK: gunakan konstanta
const (
    DaysInWeek = 7
    HoursInDay = 24
    MinutesInHour = 60
)

func calculateWeeklyHours(dailyHours int) int {
    return dailyHours * DaysInWeek
}

// KURANG BAIK: magic numbers
func calculateWeeklyHours(dailyHours int) int {
    return dailyHours * 7  // 7 itu apa?
}

4. Gunakan Type yang Tepat

// BAIK: type yang sesuai
const (
    ServerPort    uint16  = 8080    // port number
    MaxUsers      int     = 1000    // jumlah user
    TimeoutSec    float64 = 30.5    // timeout dalam detik
    IsProduction  bool    = false   // flag environment
)

Latihan

Latihan 1: Konstanta Dasar

package main

import "fmt"

func main() {
    // TODO: Buat konstanta untuk:
    // - nama lengkap kamu (string)
    // - umur kamu (int) 
    // - tinggi badan dalam meter (float64)
    // - status pelajar (bool)
    
    // Tampilkan semua konstanta dengan format yang rapi
}

Latihan 2: Konstanta Matematika

package main

import "fmt"

// TODO: Buat konstanta untuk:
// - Pi (3.14159)
// - Gravitasi bumi (9.81 m/s²)
// - Kecepatan cahaya (299792458 m/s)

// TODO: Buat function untuk menghitung:
// - Luas lingkaran berdasarkan radius
// - Kecepatan jatuh bebas berdasarkan waktu
// - Jarak yang ditempuh cahaya dalam waktu tertentu

func main() {
    // Test semua function yang sudah dibuat
}

Latihan 3: Konstanta untuk Status

package main

import "fmt"

// TODO: Buat konstanta untuk status order:
// - "draft", "submitted", "processing", "shipped", "delivered", "cancelled"

// TODO: Buat function processOrder(status string) yang:
// - Menerima status sebagai parameter
// - Menampilkan pesan sesuai status
// - Menggunakan switch case

func main() {
    // TODO: Test function dengan berbagai status
}

Latihan 4: Konfigurasi Aplikasi

package main

import "fmt"

// TODO: Buat konstanta untuk konfigurasi web server:
// - Server host (localhost)
// - Server port (8080)
// - Max connections (100)
// - Request timeout (30 detik)
// - Static files directory ("/static")

// TODO: Buat function startServer() yang menampilkan info server
// TODO: Buat function isValidConnection(current int) yang cek apakah 
//       jumlah koneksi saat ini melebihi batas maksimal

func main() {
    // Test semua function
}

Kesimpulan

Konstanta adalah fitur penting di Go untuk menyimpan nilai yang tidak berubah. Poin-poin penting yang perlu diingat:

• Gunakan const untuk mendeklarasikan konstanta
• Konstanta harus diinisialisasi saat deklarasi
• Nilai konstanta tidak bisa diubah setelah dideklarasikan
• Konstanta mendukung type inference
• Bisa mendeklarasikan multiple konstanta sekaligus
• Konstanta tanpa nilai akan mengikuti nilai konstanta di atasnya
• Gunakan konstanta untuk magic numbers, konfigurasi, dan nilai tetap
• Kelompokkan konstanta yang berkaitan untuk organisasi yang lebih baik

Dengan memahami konstanta, kamu bisa membuat kode yang lebih aman dan mudah dipelihara. Nilai-nilai yang memang tidak akan berubah sebaiknya dideklarasikan sebagai konstanta untuk mencegah kesalahan dan membuat kode lebih readable. Di bab selanjutnya, kita akan belajar tentang operator untuk memanipulasi data.