Go પેકેજ અને મોડ્યુલ કોડને કેવી રીતે ગોઠવે છે?

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 ઇકોસિસ્ટમ સાથે વ્યવહારિક સુધરેલતા પ્રતિબિંબિત કરે છે.