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/` डिरेक्टरी विशेष छ — यसका प्याकेजहरू एकै मोड्युल भित्रबाट मात्र आयात गर्न सकिन्छ, मोड्युल स्तरमा encapsulation लागु गर्दै।

## यो किन महत्त्वपूर्ण छ

प्याकेज र मोड्युल हरू कसरी Go प्रकल्पहरू संरचित गरिन्छ र कसरी निर्भरताहरू व्यवस्थापन गरिन्छ — कुनै पनि वास्तविक प्रकल्पको लागि अत्यावश्यक।

प्याकेजहरू (फाइलहरूको डिरेक्टरी, राजकीयकरण-आधारित निर्यात/अनिर्यात दृश्यमानता, विशेष `main` प्याकेज) बुझ्नु कोड संगठित गर्न र यसको सार्वजनिक API नियन्त्रण गर्न आधारभूत छ।

मोड्युलहरू (`go mod`, `go.mod`/`go.sum`) पुनरुत्पादनीय, संस्करण-नियन्त्रित, सत्यता-जाँच गरिएको निर्भरता व्यवस्थापन प्रदान गर्छ — आधुनिक मानक जसले पुरानो GOPATH दृष्टिकोणको स्थान लिएको छ।

import प्रणाली, `internal/` सम्मेलन मोड्युल-निजी कोडको लागि, र उपकरणहरू (`go mod init/tidy`, `go get`) जान्नु Go प्रकल्पहरू निर्माण, साझेदारी, र रखरखाव गर्न आवश्यक छ, र Go इकोसिस्टमको साथ व्यावहारिक दक्षता प्रतिफलित गर्छ।