คุณประกาศตัวแปรอย่างไร และชนิดข้อมูลพื้นฐานของ Go มีอะไรบ้าง?

Question

Accepted Answer

Go เป็นภาษาที่กำหนดชนิดแบบ static และมีหลายวิธีในการประกาศตัวแปร วิธีที่ใช้บ่อยที่สุดคือ **short declaration** `:=` ซึ่งจะอนุมานชนิดให้เอง ชนิดข้อมูลพื้นฐานของ Go ครอบคลุมตัวเลข สตริง บูลีน และอื่น ๆ

## การประกาศตัวแปร

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

`:=` เป็นวิธีที่เป็นสำนวน (idiomatic) สำหรับการใช้ภายในฟังก์ชัน — กระชับด้วยการอนุมานชนิด ส่วน `var` ใช้ในระดับ package และเมื่อคุณต้องการระบุชนิดอย่างชัดเจน หรือเพียงต้องการค่า zero value

## ชนิดข้อมูลพื้นฐาน

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

## Zero values — ไม่มีตัวแปรที่ "ยังไม่ถูกกำหนดค่า"

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

คุณสมบัติสำคัญของ Go: ทุกตัวแปรที่ถูกประกาศจะได้รับ **zero value** ที่เหมาะสมโดยอัตโนมัติ — ไม่มีค่าที่ไม่ถูกกำหนด (undefined) หรือค่าขยะ (garbage) สิ่งนี้ทำให้โค้ดปลอดภัยยิ่งขึ้น และหมายความว่าคุณมักจะข้ามการกำหนดค่าเริ่มต้นอย่างชัดเจนได้

## การแปลงชนิดต้องทำอย่างชัดเจน

```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 กำหนดให้การแปลงชนิดต้องทำอย่าง **ชัดเจน** — มันจะไม่ผสมชนิดข้อมูลโดยอัตโนมัติ ซึ่งช่วยป้องกันบั๊กที่ละเอียดอ่อนได้ทั้งกลุ่มหนึ่ง

## ทำไมจึงสำคัญ

การเข้าใจการประกาศตัวแปรและชนิดข้อมูลของ Go เป็นพื้นฐานสำหรับการเขียน Go ใด ๆ ก็ตาม

การประกาศแบบสั้น `:=` ที่เป็นสำนวนพร้อมการอนุมานชนิดช่วยให้โค้ดกระชับ ในขณะที่ `var` และค่าคงที่ก็มีบทบาทของตัวเอง

**การรับประกัน zero value** (ทุกตัวแปรถูกกำหนดค่าเริ่มต้นอย่างปลอดภัย) เป็นคุณสมบัติเด่นและสำคัญของ Go ที่กำจัดบั๊กจากตัวแปรที่ยังไม่ถูกกำหนดค่า และเป็นตัวกำหนดรูปแบบที่เป็นสำนวน (เช่น struct ที่มีค่าเป็น zero มักใช้งานได้เลย)

และการที่ Go ยืนกรานเรื่องการ **แปลงชนิดอย่างชัดเจน** (ไม่มี implicit coercion) เป็นการเลือกด้านความปลอดภัยอย่างจงใจ ที่ป้องกันบั๊กตัวเลขแบบเงียบ ๆ ที่ภาษาอื่นยอมให้เกิดขึ้น

การรู้จักชนิดข้อมูลพื้นฐาน (โดยเฉพาะ `rune` สำหรับ Unicode, `byte` และการที่ `int`/`float64` เป็นค่าเริ่มต้น) เป็นความรู้ที่จำเป็นในการใช้งานประจำวัน