Paketlar va modullar

Loyiha o'sgani sari kodni bo'lish kerak bo'ladi. Go da buning ikki darajasi bor: paket va modul.

Ikki daraja #

Modul - bu go.mod fayli turgan papka va uning ichidagi hamma narsa.

Katta harf - ko'rinuvchanlik #

Go da public va private kalit so'zlari yo'q. Buning o'rniga nomning birinchi harfi hal qiladi.

package hisob

// Qosh - tashqaridan ko'rinadi (katta harf)
func Qosh(a, b int) int {
    return a + b
}

// tekshir - faqat shu paket ichida (kichik harf)
func tekshir(son int) bool {
    return son >= 0
}

type Talaba struct {
    Ism  string // ko'rinadi
    ball int    // ko'rinmaydi
}

Bu qoida hamma narsaga taalluqli: funksiya, tur, o'zgaruvchi, doimiy va struktura maydonlari.

Import qilish #

package main

import (
    "fmt"
    "strings"

    "misol.uz/maktab/hisob"
)

func main() {
    fmt.Println(hisob.Qosh(2, 3))
    fmt.Println(strings.ToUpper("salom"))
}

Import yo'li - papkaning to'liq yo'li, paket nomi emas. Lekin kodda paket nomi ishlatiladi.

Odatda ular bir xil bo'ladi, shuning uchun chalkashlik kam.

gofmt importlarni ikki guruhga ajratadi: standart kutubxona yuqorida, qolganlari pastda.

Taxalluslar #

import (
    "math/rand"

    krand "crypto/rand"

    _ "github.com/lib/pq"

    . "fmt"
)

go.mod fayli #

module misol.uz/maktab

go 1.24

require (
    github.com/google/uuid v1.6.0
    golang.org/x/text v0.14.0 // indirect
)

Bog'liqlik qo'shish uchun uni kodda import qilib, keyin shu buyruqni berasiz:

go mod tidy

go mod tidy kodni o'qib chiqadi: yetishmaydiganini yuklaydi, ortiqchasini olib tashlaydi.

go.sum nima uchun kerak #

internal papkasi #

misol.uz/maktab/internal/baza    <- faqat maktab ichidan
misol.uz/maktab/hisob            <- hamma joydan

init funksiyasi #

package main

import "fmt"

var sozlama = tayyorla()

func tayyorla() string {
    fmt.Println("1. o'zgaruvchi tayyorlandi")
    return "asosiy"
}

func init() {
    fmt.Println("2. init ishladi:", sozlama)
}

func main() {
    fmt.Println("3. main ishladi")
}

1. o'zgaruvchi tayyorlandi
2. init ishladi: asosiy
3. main ishladi

init - paket yuklanganda avtomatik chaqiriladigan funksiya. U main dan oldin ishlaydi.

Tartib qat'iy: avval paket o'zgaruvchilari, keyin init, keyin main.

Hujjatlash #

// Package hisob oddiy matematik amallarni bajaradi.
package hisob

// Qosh ikki sonning yig'indisini qaytaradi.
//
// Salbiy sonlar ham qabul qilinadi.
func Qosh(a, b int) int {
    return a + b
}

Go da hujjat - bu oddiy izoh. Alohida sintaksis yo'q.

Qoida: izoh e'lon qilinayotgan nom bilan boshlanishi kerak - Qosh ikki sonning....

Keyin uni ko'rish mumkin:

go doc misol.uz/maktab/hisob Qosh

Aynan shu izohlardan pkg.go.dev saytidagi hujjatlar yasaladi.

Foydali standart paketlar #

package main

import (
    "fmt"
    "os"
    "strings"
    "time"
)

func main() {
    muddat := 90 * time.Minute
    fmt.Println(muddat)
    fmt.Println(muddat.Hours())

    yol := strings.Join([]string{"hujjatlar", "hisobot.txt"}, "/")
    fmt.Println(yol)

    fmt.Println(len(os.Args) > 0)
}

1h30m0s
1.5
hujjatlar/hisobot.txt
true

time.Duration ning String() metodi bor - shuning uchun 90 * time.Minute odam o'qiy oladigan shaklda chiqdi.

Xulosa #

• Paket - bitta papka; modul - go.mod bor papka va uning ichidagilar.
• Ko'rinuvchanlikni nomning birinchi harfi hal qiladi: katta - tashqariga chiqadi.
• Import yo'li - papka yo'li, kodda esa paket nomi ishlatiladi.
• _ importi faqat init uchun; nuqtali importdan saqlaning.
• go mod tidy bog'liqliklarni kod bo'yicha tartibga soladi.
• go.sum bog'liqliklarning barmoq izini saqlaydi - uni ham git ga qo'shing.
• internal papkasi faqat shu modul ichidan ko'rinadi.
• init main dan oldin ishlaydi, lekin uni kam ishlating.
• Hujjat - oddiy izoh; u e'lon qilinayotgan nom bilan boshlanadi.

Keyingi bo'limda generiklarni o'rganamiz.