Go कोड कसे organize करतात packages आणि modules?

Question

IT Interview Practice · Accepted Answer

Go कोड **packages** (एका डिरेक्टरीमध्ये source files चा संग्रह) आणि **modules** (versioned dependencies सह packages चा संग्रह) द्वारे organize करतात. एकत्रितपणे ते projects structure करतात आणि dependencies manage करतात.

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

एका डिरेक्टरीतील सर्व files एका package चे आहेत. **Capitalization visibility नियंत्रित करते**: capitalized नावे exported आहेत (packages मधील public), lowercase package साठी private आहेत.

## Packages import आणि use करणे

```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 — versioned dependency management

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

एक **module** (Go 1.11 मध्ये सादर केलेला) dependency management चा युनिट आहे — `go.mod` exact dependency versions list करतो, builds reproducible बनवितो. `go.sum` dependency integrity verify करतो.

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

## Project structure conventions

```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 केवळ same module मध्ये import करता येतात, module level वर encapsulation enforce करतात.

## हे महत्वाचे का आहे

Packages आणि modules कसे Go projects structure केले जातात आणि कसे dependencies manage केल्या जातात — कोणत्याही वास्तविक project साठी आवश्यक आहे.

Packages समजणे (files ची डिरेक्टरी, capitalization-आधारित exported/unexported visibility, विशेष `main` package) कोड organize करणे आणि त्याचे public API नियंत्रित करणे fundamental आहे.

Modules (`go mod`, `go.mod`/`go.sum`) reproducible, versioned, integrity-checked dependency management प्रदान करतात — आधुनिक standard जी जुन्या GOPATH approach ची जागा घेतली.

Import system, module-private code साठी `internal/` convention, आणि tooling (`go mod init/tidy`, `go get`) जाणणे Go projects build, share, आणि maintain करण्यासाठी आवश्यक आहे, आणि Go ecosystem सह practical fluency प्रतिबिंबित करते.

Packages — संबंधित कोडची डिरेक्टरी

Packages import आणि use करणे

Modules — versioned dependency management

init function आणि main

Project structure conventions

हे महत्वाचे का आहे

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