Bagaimana Anda mendeklarasikan variabel dan apa saja tipe dasar Go?

Question

Accepted Answer

Go adalah tipe statis dengan beberapa cara untuk mendeklarasikan variabel. Yang paling umum adalah **deklarasi pendek** `:=`, yang menyimpulkan tipe. Tipe dasar Go mencakup angka, string, boolean, dan banyak lagi.

## Mendeklarasikan variabel

```go
var x int = 42        // full form: explicit type and value
var y = 42            // type inferred → int
var z int             // declared, ZERO-valued (z = 0)

name := "Ann"         // short declaration (:=) — infers type, INSIDE functions only
count := 10

var a, b = 1, "two"   // multiple at once
const Pi = 3.14159     // constant (compile-time)
```

`:=` adalah cara idiomatis dalam fungsi — ringkas dengan inferensi tipe. `var` digunakan di tingkat paket dan ketika Anda menginginkan tipe eksplisit atau hanya nilai nol.

## Tipe dasar

```go
// integers
int, int8, int16, int32, int64     // signed (int is platform-sized, usually 64-bit)
uint, uint8, ..., uint64           // unsigned
byte                                // alias for uint8
rune                                // alias for int32 — a Unicode code point

// floating point
float32, float64                    // float64 is the default for decimals

// others
string                              // immutable UTF-8 text
bool                               // true / false
complex64, complex128              // complex numbers
```

## Nilai nol — tidak ada variabel "tidak diinisialisasi"

```go
var i int       // 0
var f float64   // 0.0
var s string    // "" (empty)
var b bool      // false
var p *int      // nil
```

Fitur penting Go: setiap variabel yang dideklarasikan secara otomatis mendapatkan **nilai nol** yang masuk akal — tidak ada nilai yang tidak terdefinisi atau sampah. Ini membuat kode lebih aman dan berarti Anda sering dapat melewati inisialisasi eksplisit.

## Konversi tipe bersifat eksplisit

```go
var i int = 42
var f float64 = float64(i)   // MUST convert explicitly — no implicit coercion
var u uint = uint(f)
// i + f  → ❌ compile error: mismatched types
```

Go memerlukan konversi tipe **eksplisit** — tidak pernah secara implisit mencampur tipe, mencegah sekelompok bug halus.

## Mengapa ini penting

Memahami deklarasi variabel dan tipe Go adalah fundamental untuk menulis Go apa pun.

Deklarasi pendek idiomatis `:=` dengan inferensi membuat kode ringkas, sementara `var` dan konstanta melayani peran mereka.

Garansi **nilai nol** (setiap variabel diinisialisasi dengan aman) adalah fitur Go yang khas dan penting yang menghilangkan bug variabel yang tidak diinisialisasi dan membentuk pola idiomatis (misalnya, struct bernilai nol sering dapat digunakan).

Dan настойчивость Go pada **konversi tipe eksplisit** (tidak ada konversi implisit) adalah pilihan keamanan yang disengaja yang mencegah jenis bug numerik diam-diam yang diizinkan bahasa lain.

Mengetahui tipe dasar (terutama `rune` untuk Unicode, `byte`, dan bahwa `int`/`float64` adalah standar) adalah pengetahuan sehari-hari yang penting.