Bagaimana anda mengisytiharkan pemboleh ubah dan apakah jenis asas Go?

Question

Accepted Answer

Go adalah jenis statik dengan beberapa cara untuk mengisytiharkan pemboleh ubah. Yang paling biasa ialah **pengisytiharan pendek** `:=`, yang membuat kesimpulan jenis. Jenis asas Go meliputi nombor, rentetan, boolean, dan banyak lagi.

## Mengisytiharkan pemboleh ubah

```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)
```

`:=` ialah cara idiomatik dalam fungsi — ringkas dengan inferens jenis. `var` digunakan pada peringkat pakej dan apabila anda mahukan jenis eksplisit atau sekadar nilai sifar.

## Jenis asas

```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 sifar — tiada pemboleh ubah "tidak dipulakan"

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

Ciri penting Go: setiap pemboleh ubah yang diisytiharkan mendapat nilai sifar **yang masuk akal** secara automatik — tiada nilai tidak ditentukan/sampah. Ini menjadikan kod lebih selamat dan bermakna anda sering dapat melangkau permulaan eksplisit.

## Penukaran jenis adalah 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 penukaran jenis **eksplisit** — ia tidak pernah secara tersirat mencampur jenis, mencegah kelas pepijat halus.

## Mengapa ia penting

Memahami pengisytiharan pemboleh ubah dan jenis Go adalah asas untuk menulis sebarang Go.

Pengisytiharan pendek idiomatik `:=` dengan inferens mengekalkan kod ringkas, manakala `var` dan pemalar melayani peranan mereka.

Jaminan **nilai sifar** (setiap pemboleh ubah dimulakan dengan selamat) adalah ciri Go yang tersendiri dan penting yang menghapuskan pepijat pemboleh ubah tidak diinisialisasi dan membentuk corak idiomatik (cth, struktur bernilai sifar sering boleh digunakan).

Dan tekad Go terhadap **penukaran jenis eksplisit** (tanpa paksaan tersirat) adalah pilihan keselamatan yang disengajakan yang mencegah jenis pepijat berangka senyap yang bahasa lain benarkan.

Mengetahui jenis asas (terutama `rune` untuk Unicode, `byte`, dan bahawa `int`/`float64` adalah lalai) ialah pengetahuan penting setiap hari.