როგორ აორგანიზებს 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

პროექტის სტრუქტურის კონვენციები

რატომ არის ეს მნიშვნელოვანი

დაკავშირებული კითხვები