Go पैकेज और मॉड्यूल कोड को कैसे व्यवस्थित करते हैं?

Question

IT Interview Practice · 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 पारिस्थितिकी के साथ व्यावहारिक प्रवाहिता को दर्शाता है।

पैकेज — संबंधित कोड की एक निर्देशिका

पैकेज को आयात करना और उपयोग करना

मॉड्यूल — संस्करण निर्भरता प्रबंधन

init फ़ंक्शन और main

परियोजना संरचना सम्मेलन

यह क्यों महत्वपूर्ण है

संबंधित प्रश्न