Packages, Modules และ Imports

Packages: ระบบโมดูลของ Go

TypeScript ใช้ ES modules (import/export) ร่วมกับ npm ในการจัดการ package ส่วน Go มีแนวคิดที่คล้ายกัน: package (ไดเรกทอรีของไฟล์ .go ที่ใช้คำประกาศ package ร่วมกัน) และ module (กลุ่มของ package ที่นิยามโดย go.mod เทียบได้กับ package.json)

Packages และคำประกาศ package

ไฟล์ Go ทุกไฟล์เริ่มต้นด้วย package <name> ไฟล์ในไดเรกทอรีเดียวกันใช้ package ร่วมกัน ส่วนโปรแกรมที่รันได้ใช้ package main

// TypeScript: file is automatically a module
export function add(a: number, b: number): number {
    return a + b;
}
export const PI = 3.14159;

// Go: explicit package declaration
package mathutil

func Add(a, b int) int {
    return a + b
}

const PI = 3.14159

Exported เทียบกับ unexported identifiers

ระบบ export ของ Go เรียบง่ายอย่างหมดจด: ขึ้นต้นด้วยตัวพิมพ์ใหญ่ → exported (public) ขึ้นต้นด้วยตัวพิมพ์เล็ก → unexported (เป็น private ภายใน package) ไม่ต้องใช้คีย์เวิร์ด export

// TypeScript: explicit export keyword
export function PublicFunc() { ... }
function privateFunc() { ... }   // not exported

export class PublicClass { ... }
class InternalClass { ... }

// Go: capitalisation IS the export keyword
func PublicFunc() { ... }   // exported — capital P
func privateFunc() { ... }  // unexported — lowercase p

type PublicStruct struct { ... }
type internalStruct struct { ... }

go.mod — สิ่งเทียบเท่ากับ package.json

// package.json (npm)
{
  "name": "my-app",
  "version": "1.0.0",
  "dependencies": {
    "express": "^4.18.0"
  }
}

// Add dependency:
// npm install express

// go.mod
module github.com/user/my-app

go 1.22

require (
    github.com/gin-gonic/gin v1.9.1
)

// Add dependency:
// go get github.com/gin-gonic/gin

การ import package

// TypeScript
import { readFileSync } from 'fs';
import express from 'express';
import { add } from './mathutil';

// Go
import (
    "os"                           // stdlib
    "github.com/gin-gonic/gin"     // third-party
    "github.com/user/app/mathutil" // local package
)

ลองเล่นดู

Open in Playground

package main

import (
  "fmt"
  "strings"
  "unicode"
)

func isExported(name string) bool {
  if name == "" {
    return false
  }
  return unicode.IsUpper(rune(name[0]))
}

func main() {
  names := []string{"Println", "printf", "HTTP", "myHelper", "PublicAPI"}
  for _, n := range names {
    status := "unexported"
    if isExported(n) {
      status = "EXPORTED"
    }
    fmt.Printf("%-12s -> %s\n", n, status)
  }

  s := "go for typescript developers"
  fmt.Println(strings.ToTitle(s))
}

🟦 การขึ้นต้นด้วยตัวพิมพ์ใหญ่เป็นกลไกการ export

นี่เป็นหนึ่งในตัวเลือกการออกแบบที่โดดเด่นที่สุดของ Go ไม่มี คีย์เวิร์ด public, private, protected หรือ export ตัวอักษรตัวแรกของ identifier ใดๆ (ฟังก์ชัน, type, ตัวแปร, ค่าคงที่, field ของ struct) เป็นตัวกำหนด visibility:

Exported — ตัวอักษรแรกเป็นตัวพิมพ์ใหญ่ — มองเห็นได้นอก package
unexported — ตัวอักษรแรกเป็นตัวพิมพ์เล็ก — เป็น private ภายใน package

type User struct {
    Name  string  // exported field
    email string  // unexported field — callers can't access this
}

แค่อ่านโค้ด คุณก็ดูจากตัว identifier ได้ทันทีว่าเป็นส่วนหนึ่งของ public API ของ package หรือไม่

🟦 init() — การ initialize ของ package

แต่ละ package ของ Go มีฟังก์ชัน init() ได้ ซึ่งจะรันอัตโนมัติเมื่อ package ถูก import ครั้งแรก ก่อน main() คุณเรียก init() เองโดยตรงไม่ได้

package db

var pool *sql.DB

func init() {
    var err error
    pool, err = sql.Open("postgres", os.Getenv("DATABASE_URL"))
    if err != nil {
        log.Fatal(err)
    }
}

สิ่งเทียบเท่าใน Node.js คือโค้ดระดับ top-level ที่รันเมื่อโมดูลถูก require() ครั้งแรก แต่ init() ของ Go นั้นชัดเจนและมีนิยามที่แน่นอน