ਪੈਕੇਜ ਅਤੇ ਮਾਡਿਊਲ Go ਕੋਡ ਨੂੰ ਕਿਵੇਂ ਸੰਗਠਿਤ ਕਰਦੇ ਹਨ?

Question

Accepted Answer

Go **packages** (ਇੱਕ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਸਰੋਤ ਫਾਈਲਾਂ ਦੇ ਸੰਗ੍ਰਹਿ) ਅਤੇ **modules** (ਸੰਸਕਰਣ ਕੀਤੀਆਂ ਨਿਰਭਰਤਾਵਾਂ ਦੇ ਨਾਲ ਪੈਕੇਜਾਂ ਦੇ ਸੰਗ੍ਰਹਿ) ਦੇ ਨਾਲ ਕੋਡ ਨੂੰ ਸੰਗਠਿਤ ਕਰਦਾ ਹੈ। ਇਹ ਇਕੱਠੇ ਪ੍ਰੋਜੈਕਟਾਂ ਨੂੰ ਬਣਾਉਂਦੇ ਹਨ ਅਤੇ ਨਿਰਭਰਤਾਵਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦੇ ਹਨ।

## ਪੈਕੇਜ — ਸਬੰਧਤ ਕੋਡ ਦੀ ਇੱਕ ਡਾਇਰੈਕਟਰੀ

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

ਇੱਕ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਸਾਰੀਆਂ ਫਾਈਲਾਂ ਇੱਕ ਪੈਕੇਜ ਨਾਲ ਸਬੰਧਤ ਹਨ। **ਕੈਪੀਟਲਾਈਜ਼ੇਸ਼ਨ ਦਿਸ਼ਾਨਿਰਦੇਸ਼ ਨਿਯੰਤਰਣ ਕਰਦਾ ਹੈ**: ਆਡੀ ਨਾਮ ਰਾਂ export ਕੀਤੇ ਜਾਂਦੇ ਹਨ (ਪੈਕੇਜਾਂ ਵਿੱਚ ਜਨਤਕ), ਛੋਟੇ ਅੱਖਰ ਪੈਕੇਜ ਲਈ ਨਿਜੀ ਹੁੰਦੇ ਹਨ।

## ਪੈਕੇਜਾਂ ਨੂੰ ਇਮਪੋਰਟ ਅਤੇ ਵਰਤਣਾ

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

ਇੱਕ **module** (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/` ਡਾਇਰੈਕਟਰੀ ਵਿਸ਼ੇਸ਼ ਹੈ — ਇਸ ਦੀਆਂ ਪੈਕੇਜਾਂ ਸਿਰਫ ਇੱਕੋ ਮਾਡਿਊਲ ਦੇ ਅੰਦਰ import ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ, ਮਾਡਿਊਲ ਪੱਧਰ ਤੇ ਇਨਕੈਪਸੂਲੇਸ਼ਨ ਨੂੰ ਲਾਗੂ ਕਰਦੀਆਂ ਹਨ।

## ਇਹ ਕਿਉਂ ਮਹੱਤਵਪੂਰਨ ਹੈ

ਪੈਕੇਜ ਅਤੇ ਮਾਡਿਊਲ ਉਹ ਤਰੀਕੇ ਹਨ ਜਿਨ੍ਹਾਂ ਨਾਲ Go ਪ੍ਰੋਜੈਕਟਾਂ ਨੂੰ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਨਿਰਭਰਤਾਵਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਿਵੇਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ — ਕਿਸੇ ਵੀ ਅਸਲੀ ਪ੍ਰੋਜੈਕਟ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

ਪੈਕੇਜਾਂ ਨੂੰ ਸਮਝਣਾ (ਫਾਈਲਾਂ ਦੀ ਇੱਕ ਡਾਇਰੈਕਟਰੀ, ਕੈਪੀਟਲਾਈਜ਼ੇਸ਼ਨ-ਆਧਾਰਿਤ export ਕੀਤਾ/unexported ਦਿੱਖ, ਵਿਸ਼ੇਸ਼ `main` ਪੈਕੇਜ) ਕੋਡ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ ਅਤੇ ਇਸਦੇ public API ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਬੁਨਿਆਦੀ ਹੈ।

ਮਾਡਿਊਲ (`go mod`, `go.mod`/`go.sum`) ਦੋਵੈਨਯੋਗ, ਸੰਸਕਰਣਿਤ, ਸੁਦ੃ਢਤਾ-ਜਾਂਚ ਕੀਤੀ ਨਿਰਭਰਤਾ ਪ੍ਰਬੰਧਨ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ — ਆਧੁਨਿਕ ਮਾਨਕ ਜੋ ਪੁਰਾਣੀ GOPATH ਵਿਧੀ ਦੀ ਜਗ੍ਹਾ ਲੈਂਦੇ ਹਨ।

Import ਪ੍ਰਣਾਲੀ, ਮਾਡਿਊਲ-ਪ੍ਰਾਈਵੇਟ ਕੋਡ ਲਈ `internal/` ਸੰਮੇਲਨ, ਅਤੇ ਟੂਲਿੰਗ (`go mod init/tidy`, `go get`) ਨੂੰ ਜਾਣਨਾ Go ਪ੍ਰਾਜੈਕਟਾਂ ਨੂੰ ਬਣਾਉਣ, ਸਾਂਝਾ ਕਰਨ, ਅਤੇ ਬਣਾਈ ਰੱਖਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ, ਅਤੇ Go ਈਕੋਸਿਸਟਮ ਦੇ ਨਾਲ ਅਮਲੀ ਲਿਹਾਜ਼ ਦੀ ਪ੍ਰਤੀਬਿੰਬ ਕਰਦਾ ਹੈ।