Go ที่ไม่มีใน TypeScript

ทำไม Go บางอย่างถึงไม่มีใน TypeScript

TypeScript เป็น layer ที่วางซ้อนบน JavaScript รันบน runtime ที่มี garbage collector (V8 หรือ Deno) และทุก object เป็น reference โดยอัตโนมัติ ส่วน Go ออกแบบมาจากศูนย์ให้เป็นภาษา compiled, statically typed ที่ทำงานระดับ system ได้ รากฐานที่ต่างกันนี้ทำให้ Go มีฟีเจอร์ทั้งหมวดที่ TypeScript ไม่มี ไม่ใช่เพราะ TS ลืม แต่เพราะโมเดลเบื้องล่างต่างกัน

Module นี้ครอบคลุมฟีเจอร์เหล่านั้น เรียนไปทีละบทเพื่อสร้าง intuition กับส่วนของ Go ที่จะรู้สึกแปลกที่สุดในตอนแรก แต่ทรงพลังที่สุดเมื่อเข้าใจแล้ว

สิ่งที่คุณจะเรียนรู้ใน Module นี้

บทเรียน	คอนเซปต์ Go-only
Pointers	`&` / `*` — memory address แบบชัดเจน
Value vs Reference	Struct และ array คัดลอก; slice และ map แชร์ข้อมูล
Defer / Panic / Recover	cleanup แบบ deterministic และ panic handling
Struct Embedding	Composition โดยไม่ต้องใช้ class inheritance
Goroutines Preview	Lightweight thread — ไม่ใช่ async/await
Static Binaries & Toolchain	Binary เดียว, ไม่ต้องการ runtime, cross-compile ได้เร็ว
Generics Differences	Type parameter พร้อม interface constraint — ไม่ใช่ structural

จุดร่วมของทุกฟีเจอร์

ทุกฟีเจอร์มีแรงจูงใจเดียวกัน คือ ความชัดเจนและคาดเดาได้ในราคาถูก Go เลือกทำให้ side-effect มองเห็นได้ (ใครเป็นเจ้าของ memory นี้? function นี้รับ copy หรือแชร์ข้อมูลเดิม?) มากกว่าความสะดวกแบบ implicit ที่ JavaScript/TypeScript ให้ การแลกนี้ทำให้เจอบั๊กแปลก ๆ บน production น้อยลง แต่แลกกับการคิดเผื่อมากขึ้นนิดหน่อยตั้งแต่ต้น

// TypeScript ไม่มี pointer, value-copy semantics แบบชัดเจน,
// keyword defer, struct embedding, goroutine,
// หรือแนวคิด "compile เป็น static binary"
// สิ่งเหล่านี้เป็นของ Go โดยเฉพาะ

// Go — ชิมรสแต่ละคอนเซปต์ใน module นี้
package main

import "fmt"

type Logger struct{ prefix string }
func (l Logger) Log(msg string) { fmt.Println(l.prefix+":", msg) }

type Service struct {
    Logger          // embedded — ไม่ต้องมี inheritance
    name   string
}

func riskyOp() (err error) {
    defer func() {               // defer: รันเสมอเมื่อออกจาก function
        if r := recover(); r != nil {
            err = fmt.Errorf("recovered: %v", r)
        }
    }()
    panic("something went wrong")
}

func double[T int | float64](v T) T { return v * 2 } // generics

func main() {
    svc := Service{Logger: Logger{prefix: "SVC"}, name: "demo"}
    svc.Log("starting")          // method ที่ promote มาจาก Logger

    x := 10
    p := &x                      // pointer ไปยัง x
    *p = 99                      // แก้ไขผ่าน pointer
    fmt.Println("x via pointer:", x)

    err := riskyOp()
    fmt.Println("riskyOp err:", err)

    fmt.Println("double 7:", double(7))
}

🟦 ทำไมฟีเจอร์เหล่านี้ถึงมีอยู่ — เป้าหมายการออกแบบของ Go

Go ถูกสร้างที่ Google ในปี 2007 เพื่อแก้ปัญหาวิศวกรรมจริง: compile time ช้า (C++), ขาด concurrency primitives (Java), และ garbage-collection pause ที่คาดเดาไม่ได้ (หลายภาษาที่มี managed runtime) ฟีเจอร์ใน module นี้คือคำตอบโดยตรงสำหรับเป้าหมายเหล่านั้น:

Pointers — ให้ control ว่าข้อมูลจะถูก copy หรือแชร์ โดยไม่ต้องพึ่ง GC-heavy object model
Value semantics — ทำให้ data-flow ชัดเจน: struct เดินทางเป็น copy เว้นแต่คุณจงใจส่ง pointer
Defer — แทนที่ chain ของ try/finally ที่ยืดยาวด้วย one-liner cleanup ที่รันไม่ว่า function จะออกอย่างไร
Struct embedding — เปิดใช้ composition-over-inheritance โดยไม่ต้องมี class hierarchy
Goroutines — scale ไปได้ถึงล้าน concurrent task โดยใช้ lightweight M:N scheduler ไม่ใช่ OS thread
Static binaries — ship executable ชิ้นเดียวที่ไม่มี dependency ภายนอก ไม่มี node_modules, ไม่ต้องติดตั้ง runtime
Generic constraints — ป้องกัน generic function แบบ any ไม่ให้ถูกเรียกด้วย type ที่ผิด ตรวจสอบตอน compile time

ไม่มีอะไรเกิดขึ้นโดยบังเอิญ แต่ละอย่างคือ trade-off ที่จงใจออกแบบมา เพื่อให้ reason เกี่ยวกับ Go program ได้ง่ายขึ้นเมื่อ scale ใหญ่ขึ้น