0Pricing
Go Academy · บทเรียน

แพ็กเกจ: การจัดระเบียบโค้ด Go

การประกาศแพ็กเกจ การนำเข้า และชื่อที่ส่งออกได้

แพ็กเกจ: การจัดระเบียบโค้ด Go เป็นบทเรียน Go Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Go Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน

แพ็กเกจคืออะไร

ไฟล์ต้นฉบับ Go ทุกไฟล์อยู่ภายใต้แพ็กเกจหนึ่งแพ็กเกจ ชื่อแพ็กเกจจะปรากฏอยู่ด้านบนของทุกไฟล์ แพ็กเกจใช้จัดกลุ่มโค้ดที่เกี่ยวข้องกันและควบคุมการมองเห็น:

// file: math/calc.go
package math

// Exported — accessible from other packages (capital letter)
func Add(a, b int) int { return a + b }

// Unexported — package-private (lowercase)
func helper() int { return 42 }

การประกาศแพ็กเกจและเส้นทางการนำเข้า

ชื่อแพ็กเกจ (แบบสั้น) แตกต่างจากเส้นทางการนำเข้า (เส้นทางโมดูล/ไดเรกทอรีแบบเต็ม):

// Import path: github.com/myapp/util/stringutil
// Package name: stringutil (last segment by convention)
package stringutil

func Reverse(s string) string {
    r := []rune(s)
    for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
        r[i], r[j] = r[j], r[i]
    }
    return string(r)
}

การนำเข้าแพ็กเกจ

ใช้ import เพื่อนำเข้าแพ็กเกจอื่น Go กำหนดให้ต้องใช้งานการนำเข้าทั้งหมด:

package main

import (
    "fmt"                         // standard library
    "strings"                     // standard library
    "github.com/myapp/util/math"  // third-party or local
)

func main() {
    fmt.Println(strings.ToUpper("hello"))
    fmt.Println(math.Add(1, 2))
}

ตัวระบุที่ส่งออกและไม่ส่งออก

ตัวระบุที่ขึ้นต้นด้วยตัวอักษรพิมพ์ใหญ่จะส่งออก (เป็นสาธารณะ) ส่วนตัวอักษรพิมพ์เล็กจะไม่ส่งออก (ใช้ได้เฉพาะภายในแพ็กเกจ):

package server

// Exported: accessible from other packages
type Server struct {
    Addr    string   // exported field
    timeout int      // unexported field
}

// Exported method
func (s *Server) Start() error { return nil }

// Unexported helper
func (s *Server) listen() {}

แพ็กเกจ main และฟังก์ชัน func main

แพ็กเกจ main มีลักษณะพิเศษ เพราะใช้กำหนดโปรแกรมปฏิบัติการ ฟังก์ชัน main คือจุดเริ่มต้นของโปรแกรม:

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go!")
    // Program starts here and ends here
}

// All other packages are libraries — no main() needed

ฟังก์ชัน init()

แต่ละแพ็กเกจสามารถมีฟังก์ชัน init() ได้ตั้งแต่หนึ่งฟังก์ชันขึ้นไป ฟังก์ชันเหล่านี้จะทำงานก่อน main() โดยอัตโนมัติและตามลำดับการประกาศ:

package config

import "fmt"

var DB string

func init() {
    DB = "localhost:5432/mydb"
    fmt.Println("config package initialized")
}

// init runs once when the package is first imported
// Multiple init() functions per file/package are allowed

การนำเข้าแบบว่างเพื่อผลข้างเคียง

นำเข้าแพ็กเกจเพื่อใช้เฉพาะผลข้างเคียงจาก init() โดยใช้ตัวระบุว่าง:

package main

import (
    "database/sql"
    _ "github.com/lib/pq"  // registers PostgreSQL driver via init()
)

func main() {
    db, err := sql.Open("postgres", "host=localhost dbname=test")
    _ = db
    _ = err
}

การนำเข้าแบบตั้งชื่อแทน

เปลี่ยนชื่อแพ็กเกจขณะนำเข้าเพื่อหลีกเลี่ยงชื่อตัวระบุซ้ำกันหรือเพื่อให้เขียนสั้นลง:

package main

import (
    "fmt"
    gomath "math"              // alias to avoid collision
    mymath "github.com/me/math"
)

func main() {
    fmt.Println(gomath.Sqrt(16))     // 4
    fmt.Println(mymath.Add(1, 2))    // 3
}

แนวทางการตั้งชื่อแพ็กเกจ

แนวทางการตั้งชื่อแพ็กเกจ Go:

  • สั้น ใช้ตัวพิมพ์เล็ก และเป็นคำเดียว: http, json, fmt
  • ตรงกับชื่อไดเรกทอรี: util/stringutil/ → แพ็กเกจ stringutil
  • ห้ามใช้ขีดล่างหรือ camelCase ในชื่อแพ็กเกจ
  • หลีกเลี่ยงชื่อทั่วไป เช่น util, common, helper
  • ชื่อแพ็กเกจเป็นส่วนหนึ่งของตัวระบุ: ควรใช้ http.Client แทน httplib.HTTPClient

การนำเข้าแบบวนรอบ

Go ไม่อนุญาตให้มีการนำเข้าแบบวนรอบ แพ็กเกจ A ไม่สามารถนำเข้า B ได้ หาก B นำเข้า A ให้แก้ไขโดยแยกโค้ดที่ใช้ร่วมกันไปไว้ในแพ็กเกจที่สาม:

// WRONG: A imports B, B imports A — compile error
// package a imports "myapp/b"
// package b imports "myapp/a"

// SOLUTION: extract shared types to package c
// package a imports "myapp/c"
// package b imports "myapp/c"
// No circular dependency

ตรวจสอบอย่างรวดเร็ว

อะไรทำให้ตัวระบุถูกส่งออกใน Go

ทบทวน: แพ็กเกจ

แนวคิดสำคัญเกี่ยวกับแพ็กเกจ:

  • ทุกไฟล์เริ่มต้นด้วย package name
  • ตัวพิมพ์ใหญ่ = ส่งออก (สาธารณะ) ตัวพิมพ์เล็ก = ไม่ส่งออก (เฉพาะแพ็กเกจ)
  • นำเข้าโดยใช้เส้นทางแบบเต็ม และเรียกใช้ด้วยชื่อแพ็กเกจแบบสั้น
  • init() ทำงานโดยอัตโนมัติก่อน main()
  • การนำเข้าแบบว่าง _ "pkg" ใช้เฉพาะผลข้างเคียง
  • ไม่อนุญาตให้มีการนำเข้าแบบวนรอบ

คำถามที่พบบ่อย

บทเรียน “แพ็กเกจ: การจัดระเบียบโค้ด Go” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “แพ็กเกจ: การจัดระเบียบโค้ด Go” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Go Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “แพ็กเกจ: การจัดระเบียบโค้ด Go”

การประกาศแพ็กเกจ การนำเข้า และชื่อที่ส่งออกได้ คุณปฏิบัติ Go Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Go Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Go Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “แพ็กเกจ: การจัดระเบียบโค้ด Go” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Go Academy นี้ได้ไหม

ได้ บทเรียน Go Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. แพ็กเกจ: การจัดระเบียบโค้ด Go
  2. โมดูล Go ด้วย go mod
  3. การเพิ่มดีเพนเดนซีภายนอก
  4. แพ็กเกจภายในและพื้นที่ทำงาน
← กลับไปที่ Go Academy