Go కోడ్‌ను packages మరియు modules ఎలా సంస్థాగతం చేస్తాయి?

Question

Accepted Answer

Go **packages** (ఒక డైరెక్టరీలో సోర్స్ ఫైల్‌ల సమాహారం) మరియు **modules** (సంస్కరణ నిర్ణీত డిపెండెన్సీలతో packages సమాహారం) ఉపయోగించి కోడ్‌ను సంస్థాగతం చేస్తుంది. కలిసి ఈవి ప్రజెక్టులను నిర్మించి డిపెండెన్సీలను నిర్వహిస్తాయి.

## Packages — సంబంధిత కోడ్ డైరెక్టరీ

```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
```

ఒక డైరెక్టరీలోని అన్ని ఫైల్‌లు ఒక packageకు చెందుతాయి. **పెద్ద అక్షరాలు దృశ్యమానతను నియంత్రిస్తాయి**: పెద్ద అక్షరాలతో ఉన్న పేర్లు ఎందుకంటే ఎక్స్‌పోర్ట్ చేయబడ్డవి (packages మధ్య public), చిన్న అక్షరాలు packageకు private.

## Packages ను ఇంపోర్ట్ చేయడం మరియు ఉపయోగించడం

```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
```

## Modules — సంస్కరణ నిర్ణీత డిపెండెన్సీ నిర్వహణ

```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)
```

A **module** (Go 1.11లో ప్రవేశపెట్టబడింది) డిపెండెన్సీ నిర్వహణ యూనిట్ — `go.mod` ఖచ్చితమైన డిపెండెన్సీ సంస్కరణలను జాబితా చేస్తుంది, బిల్డ్‌లను పునరుత్పత్తి చేయేటట్లు చేస్తుంది. `go.sum` డిపెండెన్సీ సమగ్రతను ధృవీకరిస్తుంది.

## The init function మరియు 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/` డైరెక్టరీ ప్రత్యేకమైనది — దీని packages ఒకే module లోపల మాత్రమే ఇంపోర్ట్ చేయబడతాయి, module స్థరంలో ఎన్‌క్యాప్సులేషన్‌ను అరికట్టుకుంటుంది.

## ఇది ఎందుకు ముఖ్యమైనది

Packages మరియు modules ఎలా Go ప్రజెక్టులు నిర్మించబడ్డాయి మరియు డిపెండెన్సీలు ఎలా నిర్వహించబడతాయి — ఏ నిజమైన ప్రజెక్టుకైనా అవసరమైనవి.

Packages (ఫైల్‌ల డైరెక్టరీ, capitalization-ఆధారిత exported/unexported దృశ్యమానత, ప్రత్యేక `main` package) అర్థం చేసుకోవడం కోడ్‌ను సంస్థాగతం చేయడానికి మరియు దీని public APIని నియంత్రించడానికి ప్రాథమికమైనది.

Modules (`go mod`, `go.mod`/`go.sum`) పునరుత్పత్తి చేయదగిన, సంస్కరణ నిర్ణీత, సమగ్రత-తనిఖీ చేయబడిన డిపెండెన్సీ నిర్వహణను అందిస్తాయి — పాత GOPATH విధానాన్ని భర్తీ చేసిన ఆధునిక ప్రమాణం.

Import సిస్టమ్, module-private కోడ్ కోసం `internal/` సంప్రదాయం, మరియు టూలింగ్ (`go mod init/tidy`, `go get`) తెలుసుకోవడం Go ప్రజెక్టులను నిర్మించడానికి, పంచుకోవడానికి, మరియు నిర్వహించడానికి అవసరమైనది, మరియు Go ఎకోసిస్టమ్‌లో ఆచరణాత్మక నిపుణతను ప్రతిబింబిస్తుంది.