Paketler ve modüller Go kodunu nasıl organize eder?

Question

IT Interview Practice · Accepted Answer

Go, kodu **paketler** (bir dizindeki kaynak dosyalarının koleksiyonu) ve **modüller** (sürümü belirtilmiş bağımlılıklara sahip paket koleksiyonları) ile organize eder. Birlikte projeleri yapılandırır ve bağımlılıkları yönetir.

## Paketler — ilgili kodun dizini

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

Bir dizindeki tüm dosyalar bir pakete aittir. **Büyük harf yazımı görünürlüğü denetler**: büyük harfle başlayan isimler dışa aktarılmış (paketler arasında herkese açık), küçük harfler ise pakete özeldir.

## Paketleri içe aktarma ve kullanma

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

## Modüller — sürümü belirtilmiş bağımlılık yönetimi

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

Bir **modül** (Go 1.11'de tanıtıldı) bağımlılık yönetiminin birimidir — `go.mod` tam bağımlılık sürümlerini listeler, derlemeleri tekrarlanabilir kılar. `go.sum` bağımlılık bütünlüğünü doğrular.

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

## Proje yapısı kuralları

```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/` dizini özeldir — paketleri yalnızca aynı modül içinde içe aktarılabilir, modül düzeyinde kapsüllemeyi zorunlu kılar.

## Neden önemli

Paketler ve modüller Go projelerinin nasıl yapılandırıldığı ve bağımlılıkların nasıl yönetildiğidir — herhangi bir gerçek proje için gereklidir.

Paketleri anlamak (dosyaların bir dizini, büyük harf yazımına dayalı dışa aktarılan/aktarılmayan görünürlük, özel `main` paketi) kod organize etmek ve genel API'sini denetlemek için temeldir.

Modüller (`go mod`, `go.mod`/`go.sum`) tekrarlanabilir, sürümlü, bütünlüğü kontrol edilen bağımlılık yönetimi sağlar — eski GOPATH yaklaşımının yerini alan modern standarttır.

İçe aktarma sistemini, modüle özel kod için `internal/` kuralını ve tooling'i (`go mod init/tidy`, `go get`) bilmek Go projelerini oluşturmak, paylaşmak ve sürdürmek için gereklidir ve Go ekosistemiyle pratik akıcılığı yansıtır.

Paketler — ilgili kodun dizini

Paketleri içe aktarma ve kullanma

Modüller — sürümü belirtilmiş bağımlılık yönetimi

init fonksiyonu ve main

Proje yapısı kuralları

Neden önemli

İlgili sorular