Sintaks Dasar Go: Variables, Constants, dan Data Types – Panduan Lengkap

Menguasai Fondasi Bahasa Pemrograman Go

Setelah berhasil setup environment dan membuat Hello World, saatnya mempelajari sintaks dasar Go yang menjadi fondasi penting dalam programming. Artikel ini akan membahas secara mendalam tentang variables, constants, dan data types dalam bahasa Go.

Dalam tutorial ini, Anda akan mempelajari:

• Cara deklarasi dan inisialisasi variables di Go
• Perbedaan constants dan variables
• Semua data types yang tersedia di Go
• Best practices dalam penggunaan variables
• Common mistakes yang harus dihindari

Mengapa Sintaks Go Berbeda dan Unik?

Sintaks Go dirancang dengan filosofi “less is more” – sederhana namun powerful. Berbeda dengan bahasa lain, Go memiliki karakteristik unik:

• Type inference yang cerdas
• Short variable declaration yang praktis
• Zero values untuk semua types
• Strong typing dengan flexibility
• Explicit dalam hal conversion

Mari kita pelajari satu per satu komponen dasar ini.

Variables di Go: Deklarasi dan Inisialisasi

1. Cara Deklarasi Variables dengan var

Sintaks dasar:

var variableName dataType
var variableName dataType = value

Contoh implementasi:

package main

import "fmt"

func main() {
    // Deklarasi tanpa inisialisasi (zero value)
    var name string
    var age int
    var isActive bool
    
    fmt.Println(name)     // "" (empty string)
    fmt.Println(age)      // 0
    fmt.Println(isActive) // false
    
    // Deklarasi dengan inisialisasi
    var city string = "Jakarta"
    var population int = 10000000
    var isCapital bool = true
    
    fmt.Println(city, population, isCapital)
}

2. Type Inference dengan var

Go dapat mendeteksi tipe data secara otomatis:

func main() {
    // Go otomatis mendeteksi tipe data
    var message = "Hello Go"        // string
    var count = 42                  // int
    var price = 99.99              // float64
    var isReady = true             // bool
    
    // Verifikasi tipe data
    fmt.Printf("%T\n", message)    // string
    fmt.Printf("%T\n", count)      // int
    fmt.Printf("%T\n", price)      // float64
    fmt.Printf("%T\n", isReady)    // bool
}

3. Short Variable Declaration (:=)

Fitur paling populer di Go:

func main() {
    // Short declaration - hanya bisa di dalam function
    name := "Go Developer"
    age := 25
    salary := 50000.50
    isEmployed := true
    
    fmt.Println(name, age, salary, isEmployed)
    
    // Multiple assignment
    firstName, lastName := "John", "Doe"
    x, y, z := 1, 2, 3
    
    fmt.Println(firstName, lastName)
    fmt.Println(x, y, z)
}

4. Multiple Variable Declaration

func main() {
    // Cara 1: Satu per satu
    var a, b, c int
    var x, y, z = 1, 2, 3
    
    // Cara 2: Block declaration
    var (
        name    string = "Go"
        version float64 = 1.21
        isStable bool = true
    )
    
    // Cara 3: Short declaration
    username, email, active := "john", "john@email.com", true
    
    fmt.Println(a, b, c)
    fmt.Println(x, y, z)
    fmt.Println(name, version, isStable)
    fmt.Println(username, email, active)
}

Constants di Go: Nilai yang Tidak Berubah

1. Deklarasi Constants

Constants adalah nilai yang tidak dapat diubah setelah dideklarasikan:

package main

import "fmt"

func main() {
    // Deklarasi constant
    const Pi = 3.14159
    const AppName = "My Go App"
    const MaxUsers = 1000
    
    // Tidak bisa diubah - akan error
    // Pi = 3.14  // Error: cannot assign to Pi
    
    fmt.Println(Pi, AppName, MaxUsers)
}

2. Typed vs Untyped Constants

func main() {
    // Untyped constants (fleksibel)
    const a = 42
    const b = 3.14
    
    // Typed constants (spesifik)
    const c int = 42
    const d float64 = 3.14
    
    // Untyped bisa digunakan dengan berbagai tipe
    var x int = a
    var y float64 = a    // OK, karena a untyped
    
    // Typed harus sesuai
    var z float64 = c    // Error: cannot use c (type int) as type float64
}

3. Constants Block Declaration

const (
    StatusPending = "pending"
    StatusActive  = "active" 
    StatusInactive = "inactive"
)

// Dengan iota (auto-increment)
const (
    Sunday = iota    // 0
    Monday           // 1
    Tuesday          // 2
    Wednesday        // 3
    Thursday         // 4
    Friday           // 5
    Saturday         // 6
)

4. Enumeration dengan iota

package main

import "fmt"

const (
    // HTTP Status Codes
    StatusOK = iota + 200        // 200
    StatusCreated                // 201
    StatusAccepted               // 202
    StatusNoContent              // 203
)

const (
    // File Permissions
    ReadPermission = 1 << iota   // 1 (001)
    WritePermission              // 2 (010)
    ExecutePermission            // 4 (100)
)

func main() {
    fmt.Println(StatusOK, StatusCreated)
    fmt.Println(ReadPermission, WritePermission, ExecutePermission)
    
    // Kombinasi permissions
    fullPermission := ReadPermission | WritePermission | ExecutePermission
    fmt.Println("Full permission:", fullPermission) // 7 (111)
}

Data Types di Go: Lengkap dan Komprehensif

1. Numeric Types

Integer Types

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    // Signed integers
    var a int8 = 127        // -128 to 127
    var b int16 = 32767     // -32,768 to 32,767
    var c int32 = 2147483647 // -2^31 to 2^31-1
    var d int64 = 9223372036854775807 // -2^63 to 2^63-1
    
    // Unsigned integers
    var ua uint8 = 255       // 0 to 255
    var ub uint16 = 65535    // 0 to 65,535
    var uc uint32 = 4294967295 // 0 to 2^32-1
    var ud uint64 = 18446744073709551615 // 0 to 2^64-1
    
    // Platform dependent
    var platform int = 42    // 32 or 64 bit
    var uplatform uint = 42  // 32 or 64 bit
    
    // Special types
    var pointer uintptr = 0  // Untuk pointer arithmetic
    var ascii byte = 65      // Alias untuk uint8
    var unicode rune = 'A'   // Alias untuk int32
    
    fmt.Printf("int8: %d (size: %d bytes)\n", a, unsafe.Sizeof(a))
    fmt.Printf("int16: %d (size: %d bytes)\n", b, unsafe.Sizeof(b))
    fmt.Printf("rune: %c (value: %d)\n", unicode, unicode)
}

Floating Point Types

func main() {
    // Floating point numbers
    var price32 float32 = 99.99
    var price64 float64 = 999.9999
    
    // Default adalah float64
    var defaultFloat = 3.14  // float64
    
    // Scientific notation
    var scientific = 1.23e4   // 12300.0
    var small = 1.23e-4       // 0.000123
    
    fmt.Printf("float32: %.2f (size: %d bytes)\n", price32, unsafe.Sizeof(price32))
    fmt.Printf("float64: %.4f (size: %d bytes)\n", price64, unsafe.Sizeof(price64))
    fmt.Printf("Scientific: %.2f\n", scientific)
}

Complex Numbers

func main() {
    // Complex numbers
    var c64 complex64 = complex(5, 12)
    var c128 complex128 = complex(5, 12)
    
    // Shorthand
    var shortComplex = 5 + 12i  // complex128
    
    // Extract real and imaginary parts
    real := real(shortComplex)  // 5
    imag := imag(shortComplex)  // 12
    
    fmt.Printf("Complex64: %v\n", c64)
    fmt.Printf("Complex128: %v\n", c128)
    fmt.Printf("Real: %.0f, Imaginary: %.0f\n", real, imag)
}

2. String Type

package main

import "fmt"

func main() {
    // String literals
    var name string = "Go Programming"
    var multiline = `Ini adalah string
    yang bisa multiple line
    dan mempertahankan format`
    
    // String operations
    firstName := "John"
    lastName := "Doe"
    fullName := firstName + " " + lastName
    
    // String properties
    length := len(name)
    
    // String indexing (read-only)
    firstChar := name[0]  // byte value
    
    // String slicing
    substring := name[0:2]  // "Go"
    
    fmt.Println("Name:", name)
    fmt.Println("Length:", length)
    fmt.Printf("First char: %c (ASCII: %d)\n", firstChar, firstChar)
    fmt.Println("Substring:", substring)
    fmt.Println("Multiline:\n", multiline)
    
    // Unicode support
    emoji := "Hello 🌍 World"
    fmt.Println("Unicode:", emoji)
    fmt.Println("Byte length:", len(emoji))          // 15 (bytes)
    fmt.Println("Rune length:", len([]rune(emoji)))  // 13 (characters)
}

3. Boolean Type

func main() {
    // Boolean values
    var isActive bool = true
    var isComplete bool = false
    var defaultBool bool  // false (zero value)
    
    // Boolean operations
    var a, b = true, false
    
    fmt.Println("AND:", a && b)  // false
    fmt.Println("OR:", a || b)   // true
    fmt.Println("NOT a:", !a)    // false
    fmt.Println("NOT b:", !b)    // true
    
    // Boolean dalam kondisi
    if isActive {
        fmt.Println("Status: Active")
    }
    
    if !isComplete {
        fmt.Println("Status: Not Complete")
    }
}

4. Array Type

func main() {
    // Array declaration
    var numbers [5]int                    // [0 0 0 0 0]
    var cities [3]string                  // ["" "" ""]
    var scores = [5]int{10, 20, 30, 40, 50}
    
    // Array dengan auto length
    var fruits = [...]string{"apple", "banana", "orange"}
    
    // Array operations
    numbers[0] = 100
    numbers[4] = 500
    
    // Array properties
    fmt.Println("Numbers:", numbers)
    fmt.Println("Length:", len(numbers))
    fmt.Println("First fruit:", fruits[0])
    
    // Iterate array
    for i, score := range scores {
        fmt.Printf("Index %d: %d\n", i, score)
    }
    
    // Multi-dimensional array
    var matrix [2][3]int = [2][3]int{
        {1, 2, 3},
        {4, 5, 6},
    }
    fmt.Println("Matrix:", matrix)
}

Zero Values di Go: Konsep Penting

Zero values adalah nilai default untuk setiap tipe data:

package main

import "fmt"

func main() {
    // Zero values untuk setiap tipe
    var (
        boolZero    bool       // false
        intZero     int        // 0
        floatZero   float64    // 0.0
        stringZero  string     // ""
        pointerZero *int       // nil
        sliceZero   []int      // nil
        mapZero     map[string]int // nil
        chanZero    chan int   // nil
        funcZero    func()     // nil
    )
    
    fmt.Printf("bool zero: %v\n", boolZero)
    fmt.Printf("int zero: %d\n", intZero)
    fmt.Printf("float zero: %f\n", floatZero)
    fmt.Printf("string zero: '%s'\n", stringZero)
    fmt.Printf("pointer zero: %v\n", pointerZero)
    fmt.Printf("slice zero: %v\n", sliceZero)
    fmt.Printf("map zero: %v\n", mapZero)
    fmt.Printf("channel zero: %v\n", chanZero)
    fmt.Printf("function zero: %v\n", funcZero)
    
    // Checking for zero values
    if stringZero == "" {
        fmt.Println("String is empty")
    }
    
    if sliceZero == nil {
        fmt.Println("Slice is nil")
    }
}

Type Conversion di Go

Go tidak melakukan implicit conversion, semua konversi harus explicit:

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Numeric conversions
    var i int = 42
    var f float64 = float64(i)
    var u uint = uint(f)
    
    fmt.Printf("int: %d, float: %f, uint: %d\n", i, f, u)
    
    // String conversions
    var num int = 123
    var str string = strconv.Itoa(num)        // int to string
    var back int, _ = strconv.Atoi(str)       // string to int
    
    fmt.Printf("Number: %d, String: %s, Back: %d\n", num, str, back)
    
    // Float conversions
    var pi float64 = 3.14159
    var piStr string = strconv.FormatFloat(pi, 'f', 2, 64)
    var piBack, _ = strconv.ParseFloat(piStr, 64)
    
    fmt.Printf("Pi: %f, String: %s, Back: %f\n", pi, piStr, piBack)
    
    // Boolean conversions
    var isTrue bool = true
    var boolStr string = strconv.FormatBool(isTrue)
    var boolBack, _ = strconv.ParseBool(boolStr)
    
    fmt.Printf("Bool: %t, String: %s, Back: %t\n", isTrue, boolStr, boolBack)
    
    // Rune and byte conversions
    var char rune = 'A'
    var charStr string = string(char)
    var charByte byte = byte(char)
    
    fmt.Printf("Rune: %c, String: %s, Byte: %d\n", char, charStr, charByte)
}

Best Practices untuk Variables dan Constants

1. Naming Conventions

// ✅ Good naming
var userName string
var maxRetryCount int
const DatabaseTimeout = 30
const APIBaseURL = "https://api.example.com"

// ❌ Bad naming
var un string
var mrc int
const dbt = 30
const api_base_url = "https://api.example.com"

2. Variable Scope

package main

import "fmt"

// Package level variables
var globalVar = "I'm global"

func main() {
    // Function level variables
    var localVar = "I'm local"
    
    // Block level variables
    if true {
        var blockVar = "I'm in block"
        fmt.Println(blockVar)
        fmt.Println(localVar)    // Accessible
        fmt.Println(globalVar)   // Accessible
    }
    
    // fmt.Println(blockVar)    // Error: undefined blockVar
    
    // Short declaration dalam loop
    for i := 0; i < 3; i++ {
        fmt.Printf("Iteration %d\n", i)
    }
    // fmt.Println(i)  // Error: i tidak accessible
}

3. Kapan Menggunakan var vs :=

// Gunakan var ketika:
// 1. Deklarasi di package level
var PackageConfig = "config"

// 2. Butuh zero value
var counter int  // 0

// 3. Tipe data berbeda dari nilai
var percentage float64 = 85  // Explicit type

func exampleFunction() {
    // Gunakan := ketika:
    // 1. Di dalam function
    name := "Go"
    
    // 2. Multiple assignment
    x, y := 10, 20
    
    // 3. Short dan simple
    isActive := true
}

4. Constants vs Variables

package main

// ✅ Gunakan constants untuk nilai tetap
const (
    AppVersion = "1.0.0"
    MaxConnections = 100
    DefaultTimeout = 30
)

func main() {
    // ✅ Gunakan variables untuk nilai yang berubah
    var currentConnections int
    var userInput string
    
    // ✅ Constants untuk konfigurasi
    config := map[string]interface{}{
        "version": AppVersion,
        "maxConn": MaxConnections,
        "timeout": DefaultTimeout,
    }
    
    fmt.Println(config)
}

Common Mistakes dan Cara Menghindarinya

1. Unused Variables

// ❌ Error: unused variable
func badExample() {
    name := "Go"
    age := 25
    // Tidak menggunakan 'age' akan menyebabkan compile error
}

// ✅ Solution: Gunakan blank identifier
func goodExample() {
    name := "Go"
    _ = getName()  // Ignore return value
    fmt.Println(name)
}

func getName() string {
    return "Go Developer"
}

2. Variable Shadowing

func shadowingExample() {
    name := "Global"
    
    if true {
        name := "Local"  // Shadows outer name
        fmt.Println(name)  // "Local"
    }
    
    fmt.Println(name)  // "Global"
}

3. Type Conversion Mistakes

func conversionMistakes() {
    // ❌ Implicit conversion tidak allowed
    var i int = 42
    var f float64 = i  // Error
    
    // ✅ Explicit conversion required
    var f2 float64 = float64(i)  // OK
    
    // ❌ Precision loss tidak dicek
    var big int64 = 999999999999
    var small int32 = int32(big)  // Potential data loss
    
    fmt.Println(f2, small)
}

Practical Examples: Real-World Usage

1. Configuration Management

package main

import "fmt"

const (
    // Application constants
    AppName = "Go Web Server"
    Version = "1.0.0"
    
    // Server configuration
    DefaultPort = 8080
    MaxConnections = 1000
    ReadTimeout = 30
    WriteTimeout = 30
)

func main() {
    // Runtime variables
    var (
        serverPort = DefaultPort
        isProduction = false
        dbHost string
        dbPort int
    )
    
    // Environment-based configuration
    if isProduction {
        dbHost = "prod-db.example.com"
        dbPort = 5432
    } else {
        dbHost = "localhost"
        dbPort = 5433
    }
    
    fmt.Printf("%s v%s\n", AppName, Version)
    fmt.Printf("Server: localhost:%d\n", serverPort)
    fmt.Printf("Database: %s:%d\n", dbHost, dbPort)
}

2. User Input Processing

package main

import (
    "fmt"
    "strconv"
    "strings"
)

func processUserData() {
    // Simulated user input
    userInput := "  John Doe, 25, true  "
    
    // Clean and split input
    cleaned := strings.TrimSpace(userInput)
    parts := strings.Split(cleaned, ", ")
    
    if len(parts) != 3 {
        fmt.Println("Invalid input format")
        return
    }
    
    // Extract and convert data
    name := strings.TrimSpace(parts[0])
    ageStr := strings.TrimSpace(parts[1])
    activeStr := strings.TrimSpace(parts[2])
    
    // Type conversions with error handling
    age, err := strconv.Atoi(ageStr)
    if err != nil {
        fmt.Printf("Invalid age: %s\n", ageStr)
        return
    }
    
    isActive, err := strconv.ParseBool(activeStr)
    if err != nil {
        fmt.Printf("Invalid active status: %s\n", activeStr)
        return
    }
    
    // Use processed data
    fmt.Printf("User: %s, Age: %d, Active: %t\n", name, age, isActive)
}

func main() {
    processUserData()
}

Kesimpulan dan Langkah Selanjutnya

Selamat! Anda telah menguasai sintaks dasar Go yang mencakup:

• ✅ Variables: var, :=, dan multiple declarations
• ✅ Constants: const, iota, dan typed/untyped constants
• ✅ Data Types: Numeric, string, boolean, array
• ✅ Zero Values: Default values untuk setiap tipe
• ✅ Type Conversion: Explicit conversion di Go
• ✅ Best Practices: Naming, scope, dan common mistakes

Key takeaways:

• Go menggunakan explicit type conversion
• Short declaration (:=) hanya untuk function scope
• Zero values membuat Go predictable dan safe
• Constants dengan iota sangat powerful untuk enums
• Type inference membuat kode lebih clean

Langkah selanjutnya dalam journey belajar Go:

1. Control Flow: If statements, loops, dan switch
2. Functions: Parameters, returns, dan error handling
3. Data Structures: Slices, maps, dan structs
4. Methods dan Interfaces: OOP concept di Go

Dalam artikel berikutnya, kita akan membahas Control Flow di Go: If, Switch, dan Loops untuk melengkapi pemahaman fundamental Anda.

Seri Belajar Golang – Pemula

1. Pengenalan Golang: Mengapa Google Menciptakan Bahasa Ini?
2. Setup Environment dan Hello World di Go
3. Sintaks Dasar Go: Variables, Constants, dan Data Types
4. Control Flow di Go: If, Switch, dan Loops
5. Functions di Go: Parameter, Return Values, dan Named Returns
6. Arrays, Slices, dan Maps: Struktur Data Penting di Go

---

Artikel ini adalah bagian dari seri pembelajaran Golang di ruangrulis.com. Save artikel ini sebagai referensi sintaks Go Anda.