โครงสร้างโปรเจกต์ Go

โปรเจกต์ Go มีโครงสร้างอย่างไร

ถ้ามาจากสาย Node.js/TypeScript คุณคงคุ้นกับ package.json, tsconfig.json, โฟลเดอร์ src/ และ node_modules โปรเจกต์ Go วางโครงสร้างต่างออกไป แต่ก็เป็นระเบียบไม่แพ้กัน เข้าใจโครงสร้างนี้ตั้งแต่ต้นช่วยประหยัดเวลาไปได้หลายชั่วโมง

go.mod — package.json ของ Go

go mod init เป็นคนสร้าง go.mod ขึ้นมาเป็น root manifest ของ Go module ในไฟล์นี้จะประกาศชื่อ module (prefix ของ import path ของคุณ) และ Go version ขั้นต่ำที่ต้องใช้

// package.json
{
  "name": "my-app",
  "version": "1.0.0",
  "scripts": { "build": "tsc", "start": "node dist/index.js" },
  "dependencies": { "express": "^4.18.2" },
  "devDependencies": { "typescript": "^5.0.0" }
}

// go.mod
module github.com/yourname/myapp

go 1.22

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

// go.sum คือ lockfile (เหมือน package-lock.json)
// จัดการอัตโนมัติ — ไม่ควรแก้ด้วยตัวเอง

ชื่อ module (github.com/yourname/myapp) ไม่ใช่แค่ชื่อ — แต่คือ import path prefix ที่ใช้ทั่วทั้งโค้ดของคุณ โดย convention มักตั้งให้ตรงกับ URL ของ source repository

Package — หนึ่งต่อ directory

ใน Go package คือ directory ที่รวมไฟล์ .go ซึ่งประกาศ package name เดียวกันทั้งหมด เข้มงวดกว่า TypeScript/ESM ที่ทุกไฟล์เป็น module ของตัวเอง เพราะใน Go คุณ import ที่ระดับ package ไม่ใช่ระดับไฟล์

// TypeScript: imports ระดับไฟล์
import { UserService } from './services/user.service';
import type { User } from './models/user.model';
import * as utils from '../shared/utils';

// Go: imports ระดับ package
import (
    "github.com/yourname/myapp/internal/services"
    "github.com/yourname/myapp/internal/models"
    "github.com/yourname/myapp/pkg/utils"
)

// แล้วใช้: services.NewUserService(...)
//            models.User{...}
//            utils.SomeHelper(...)

โครงสร้างโปรเจกต์แบบ Idiomatic

ชุมชน Go ลงตัวกับ layout มาตรฐานสำหรับ service และ CLI มาแล้ว ลองมาเทียบกับโปรเจกต์ Node/TypeScript ทั่วไปดู:

// TypeScript / Node.js project
my-app/
  src/
    controllers/     # route handler
    services/        # business logic
    models/          # TypeScript interface/type
    middleware/      # Express middleware
    index.ts         # entry point
  dist/              # compiled output
  package.json
  tsconfig.json
  .env

// Go project (idiomatic layout)
myapp/
  cmd/
    myapp/
      main.go        # entry point (package main)
  internal/
    handlers/        # HTTP handler
    services/        # business logic
    models/          # struct definition
    middleware/      # HTTP middleware
  pkg/               # package ที่นำกลับมาใช้ได้ (public API)
  go.mod
  go.sum
  .env

กฎสำคัญ:

cmd/ เก็บ entry point (main package) — หนึ่ง subdirectory ต่อหนึ่ง binary
internal/ คือโค้ด private ที่ Go บังคับให้ — package ในนี้ module ภายนอก import ไม่ได้
pkg/ เก็บ package ที่คุณตั้งใจเปิดให้ภายนอกเรียกใช้

🟦 internal/ — privacy ที่ compiler enforce

ใน TypeScript โค้ด “private” เป็นแค่ convention (prefix _, barrel file, documentation) ส่วน Go บังคับเรื่องนี้ที่ระดับ compiler ผ่าน directory internal/ package ที่อยู่ใน internal/ จะ import ได้เฉพาะจากโค้ดที่อยู่ใต้ parent directory tree เดียวกันเท่านั้น

myapp/
  internal/
    database/   # เฉพาะ myapp/** ที่ import ได้
  pkg/
    utils/      # ใครก็ import ได้

// สำเร็จ (same module):
import "github.com/yourname/myapp/internal/database"

// ล้มเหลวตอน compile time (external module):
// import "github.com/yourname/myapp/internal/database"
// cannot use internal package

วิธีนี้ทำให้คุณสร้าง public API ที่เสถียรไว้ใน pkg/ ได้ พร้อมกับเก็บ implementation detail ไว้ใน internal/ แบบ private จริงๆ

Identifier ที่ exported vs unexported

ใน TypeScript คุณใช้ export กับ import ส่วนใน Go ตัวอักษรแรกของชื่อ identifier เป็นตัวกำหนด visibility — ไม่ต้องมี keyword export

// TypeScript: export แบบ explicit
export interface User { id: string; name: string; }
export function greet(name: string): string {
  return `Hello, ${name}!`;
}
// helper ภายใน (ไม่มี export)
function formatName(n: string): string { return n.trim(); }

// Go: ตัวพิมพ์ใหญ่ = exported, ตัวพิมพ์เล็ก = unexported
type User struct {         // exported (U ตัวใหญ่)
    ID   string
    Name string
}

func Greet(name string) string {  // exported (G ตัวใหญ่)
    return "Hello, " + formatName(name) + "!"
}

func formatName(n string) string { // unexported (lowercase)
    return strings.TrimSpace(n)
}

ลองเลย — package และ import

Open in Playground

package main

import (
  "fmt"
  "strings"
)

// Exported function — ตัวพิมพ์ใหญ่
func Greet(name string) string {
  return "Hello, " + formatName(name) + "!"
}

// unexported helper — ตัวพิมพ์เล็ก
func formatName(n string) string {
  return strings.ToUpper(n[:1]) + n[1:]
}

func main() {
  fmt.Println(Greet("gopher"))
  fmt.Println(Greet("world"))

  // Standard library import โดย path
  // "strings" -> the strings package
  fmt.Println(strings.ToUpper("go is great"))
}