Go குறியீட்டை பொதி (package) மற்றும் தொகுதி (module) எப்படி ஒரு நிறுவப்படுகிறது?

Question

Accepted Answer

Go குறியீட்டை **பொதி** (ஒரு கோப்புறையில் உள்ள மூல கோப்புகளின் தொகுப்பு) மற்றும் **தொகுதி** (பதிப்பு மிக்க சார்பின்மைகளுடன் பொதிகளின் தொகுப்பு) மூலம் ஒരு நிறுவப்படுகிறது. இவை இணைந்து திட்டங்களை கட்டமைக்கின்றன மற்றும் சார்பின்மைகளை நிர்வகிக்கின்றன.

## பொதி — தொடர்புடைய குறியீட்டின் கோப்புறை

```go
// every .go file starts by declaring its package
package main         // "main" is special — produces an executable

// or a library package (named after its directory, conventionally)
package mathutil

func Add(a, b int) int { return a + b }   // Exported (capitalized) — usable outside
func helper() {}                           // unexported (lowercase) — package-private
```

ஒரு கோப்புறையில் உள்ள அனைத்து கோப்புகளும் ஒரு பொதிக்கு சொந்தமானவை. **பெரிய எழுத்து பார்வை கட்டுப்படுத்துகிறது**: பெரிய எழுத்துக்கள் ஆனவை ஏற்றுமதி செய்யப்பட்டவை (பொதிகள் முழுவதும் பொது), சிறிய எழுத்துக்கள் பொதிக்கு மட்டுமே தனிப்பட்டவை.

## பொதிகளை இறக்குமதி செய்தல் மற்றும் பயன்படுத்துதல்

```go
import (
    "fmt"                          // standard library
    "strings"
    "github.com/user/repo/mathutil" // a third-party or local module package
)

fmt.Println(strings.ToUpper("hi"))
mathutil.Add(2, 3)                  // use Exported names via package.Name
```

## தொகுதி — பதிப்பு மிக்க சார்பின்மை நிர்வகிப்பு

```bash
go mod init github.com/user/myapp   # create a module → makes go.mod
go get github.com/gin-gonic/gin     # add a dependency (records it in go.mod)
go mod tidy                          # add missing & remove unused dependencies
go build                             # build using the module's dependencies
```

```text
go.mod  — declares the module path, Go version, and direct dependencies (+ versions)
go.sum  — cryptographic checksums of dependencies (integrity/security)
```

ஒரு **தொகுதி** (Go 1.11 இல் அறிமுகப்படுத்தப்பட்டது) சார்பின்மை நிர்வகிப்பின் அலகு ஆகும் — `go.mod` சரியான சார்பின்மை பதிப்புகளை பட்டியலிடுகிறது, கட்டுமானங்களை நகலெடுக்க முடிய செய்கிறது. `go.sum` சார்பின்மை ஒற்றுமையை சரிபார்க்கிறது.

## init செயல்பாடு மற்றும் main

```go
package main

func init() {    // runs automatically when the package loads (before main)
    // setup
}
func main() {    // entry point of an executable (package main only)
}
```

## திட்ட கட்டமைப்பு மரபுகள்

```text
myapp/
  go.mod
  main.go              package main
  internal/            packages here are PRIVATE to this module (can't be imported externally)
  pkg/ or other dirs/  reusable packages
```

`internal/` கோப்புறை சிறப்பானது — இதன் பொதிகள் ஒரே தொகுதியில் மட்டுமே இறக்குமதி செய்யப்படலாம், தொகுதி மட்டத்தில் பொதுவாக்கம் செய்யப்படலாம்.

## அது ஏன் முக்கியம்

பொதி மற்றும் தொகுதி Go திட்டங்கள் எப்படி கட்டமைக்கப்பட்டுள்ளன மற்றும் சார்பின்மைகள் எப்படி நிர்வகிக்கப்படுகின்றன என்பது — எந்த நிஜ திட்டத்திற்கும் இன்றியமையாதது.

பொதிகளைப் புரிந்துகொள்ளுதல் (ஒரு கோப்புறை கோப்புகள், பெரிய எழுத்து-அடிப்படையிலான ஏற்றுமதி செய்யப்பட்ட/ஏற்றுமதி செய்யப்படாத பார்வை, சிறப்பான `main` பொதி) குறியீட்டைத் ஒரு நிறுவல் மற்றும் அதன் பொது API ஐ கட்டுப்படுத்துவது அடிப்படையாகும்.

தொகுதிகள் (`go mod`, `go.mod`/`go.sum`) சரிபார்க்கப்பட்ட, பதிப்பு மிக்க, ஒற்றுமை-சரிபார்க்கப்பட்ட சார்பின்மை நிர்வகிப்பை வழங்குகின்றன — பழையவை GOPATH அணுகுமுறையை மாற்றிய நவீன தரநிலை.

आயात அமைப்பை, தொகுதி-தனிப்பட்ட குறியீட்டிற்கான `internal/` மரபை, மற்றும் கருவிப்பொருளை (`go mod init/tidy`, `go get`) தெரிந்துகொள்ளுதல் Go திட்டங்களை கட்டுதல், பகிர்தல், மற்றும் பராமரிப்பதற்கு அவசியம், மற்றும் Go சுற்றுவட்டத்துடன் நடைமுறை சொல்வளத்தை பிரதிபலிக்கிறது.