Tarkibga o'tish

Go’da fayllarni dastur ichiga joylash: embed

embed paketi fayl va kataloglarni kompilyatsiya vaqtida Go dasturining bajariluvchi fayli (binary) ichiga joylash imkonini beradi. Natijada HTML shablon, SQL migratsiya, standart konfiguratsiya yoki kichik statik fayllarni dastur bilan birga alohida ko‘chirish shart bo‘lmaydi.

Masalan, CLI dasturga yordam matni kerak bo‘lsa, uni uzun string sifatida Go kodiga yozish noqulay. Matnni help.txt faylida saqlab, go:embed orqali dasturga qo‘shish mumkin. Matnni tahrirlash qulay qoladi, foydalanuvchiga esa bitta binary yetadi.

Go bu imkoniyatni 1.16 versiyasida standart kutubxonaga qo‘shgan. Darsdagi kodni ishga tushirish uchun undan yangi Go versiyasi kerak.

go:embed qanday ishlaydi?

//go:embed — Go kompilyatoriga mo‘ljallangan maxsus direktiva. go build yoki go run bajarilganda Go ko‘rsatilgan fayllarni o‘qiydi va ularning mazmuni bilan paket darajasidagi o‘zgaruvchini boshlang‘ich qiymatga ega qiladi.

Direktiva faqat quyidagi turlardan biriga qiymat bera oladi:

  • string — bitta matnli fayl uchun;
  • []byte — bitta matnli yoki binary fayl uchun;
  • embed.FS — bitta yoki bir nechta fayl va katalog uchun.

Fayllar runtime vaqtida diskdan o‘qilmaydi. Dastur kompilyatsiya qilingandan keyin manba fayl o‘zgarsa, binary ichidagi nusxa o‘zgarmaydi. Yangi nusxani olish uchun dasturni qayta kompilyatsiya qilish kerak.

Warning

Direktiva aynan //go:embed ko‘rinishida yoziladi. // go:embed ishlamaydi. Direktiva paket darajasidagi bitta o‘zgaruvchi deklaratsiyasidan oldin kelishi kerak. Uni func main() ichidagi lokal o‘zgaruvchiga qo‘llab bo‘lmaydi.

Bitta matnli faylni string sifatida joylash

Quyidagi ikki fayl bir katalogda tursin:

Loyiha tuzilishi
.
├── hello.txt
└── main.go

hello.txt faylining mazmuni:

hello.txt
Salom, dunyo!

main.go fayli:

main.go
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
package main

import (
    _ "embed"
    "fmt"
)

//go:embed hello.txt
var hello string

func main() {
    fmt.Print(hello)
}

Dasturni fayllar joylashgan katalogda ishga tushiring:

go run .

Natija:

Salom, dunyo!

hello paket darajasida e’lon qilingan. Kompilyator hello.txt tarkibini shu o‘zgaruvchiga yozadi. Kod embed.FS nomidan bevosita foydalanmayapti, lekin direktivani yoqish uchun embed paketini import qilish shart. Shu sababli blank import — _ "embed" ishlatilgan.

fmt.Print() tanlangan, chunki fayl oxirida yangi qator belgisi bor. fmt.Println(hello) ishlatilsa, yana bitta yangi qator qo‘shilib, natijada ortiqcha bo‘sh qator paydo bo‘lishi mumkin. Fayldagi baytlar o‘zgartirilmasdan stringga olinadi.

Binary faylni []byte sifatida joylash

Rasm, sertifikat yoki boshqa binary ma’lumot matn emas, baytlar ketma-ketligidir. Bunday fayl uchun []byte mos keladi:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
package main

import (
    _ "embed"
    "fmt"
)

//go:embed logo.png
var logo []byte

func main() {
    fmt.Printf("Rasm hajmi: %d bayt\n", len(logo))
}

Bu dastur bilan bir katalogda logo.png bo‘lishi kerak. Natijadagi son aynan shu fayl hajmiga bog‘liq:

Rasm hajmi: 4821 bayt

logo runtime vaqtida fayl yo‘lini emas, faylning o‘z baytlarini saqlaydi. Ularni HTTP javobiga yozish, xesh hisoblash yoki parserga uzatish mumkin. []byte o‘zgaruvchan bo‘lgani uchun kod uning elementlarini o‘zgartira oladi. Bunday o‘zgarish faqat joriy jarayondagi slice’ga ta’sir qiladi; diskdagi logo.png va binary ichidagi dastlabki ma’lumot qayta yozilmaydi.

Info

string va []byte uchun direktivada faqat bitta pattern bo‘lishi va u faqat bitta faylga mos kelishi kerak. Bir nechta fayl kerak bo‘lsa, embed.FS ishlating.

Bir nechta fayl uchun embed.FS

embed.FS faqat o‘qiladigan virtual fayl tizimidir. Uning ichidagi fayllarga oddiy yo‘l bilan murojaat qilinadi.

Quyidagi tuzilmani olaylik:

Loyiha tuzilishi
.
├── main.go
└── texts
    ├── file1.txt
    ├── file2.txt
    └── notes
        └── file3.txt

Fayllarning mazmuni mos ravishda Birinchi fayl, Ikkinchi fayl va Uchinchi fayl bo‘lsin.

main.go
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package main

import (
    "embed"
    "fmt"
    "io/fs"
    "log"
)

//go:embed texts
var textFiles embed.FS

func main() {
    err := fs.WalkDir(textFiles, "texts", func(path string, entry fs.DirEntry, walkErr error) error {
        if walkErr != nil {
            return walkErr
        }
        if entry.IsDir() {
            return nil
        }

        data, err := textFiles.ReadFile(path)
        if err != nil {
            return err
        }
        fmt.Printf("%s: %s\n", path, data)
        return nil
    })
    if err != nil {
        log.Fatal(err)
    }
}

Natija:

texts/file1.txt: Birinchi fayl
texts/file2.txt: Ikkinchi fayl
texts/notes/file3.txt: Uchinchi fayl

//go:embed texts katalogni ichki kataloglari bilan birga rekursiv joylaydi. fs.WalkDir() daraxtni nomlar bo‘yicha tartiblangan holda aylanadi. Callback katalogni uchratsa, uni o‘qimasdan davom etadi. Fayl uchrasa, ReadFile() uning mazmunini []byte sifatida qaytaradi.

WalkDir callback’iga kelgan walkErr albatta tekshiriladi. Uni e’tiborsiz qoldirish ayrim fayllarga kira olinmaganini yashirishi mumkin. ReadFile() xatosi ham yuqoriga qaytariladi va main() ichida log.Fatal() orqali ko‘rsatiladi.

embed.FS io/fs.FS interfeysini amalga oshiradi. Shu sababli uni fs.WalkDir, fs.ReadFile, html/template, text/template va net/http kabi standart paketlar bilan ishlatish mumkin.

Pattern yozish qoidalari

Direktivadan keyingi yo‘l pattern deb ataladi. Pattern main.go turgan paket katalogiga nisbatan hisoblanadi, modul ildiziga nisbatan emas. Windows tizimida ham ajratuvchi sifatida / yoziladi.

//go:embed templates/*.html static/css/*.css
var content embed.FS

Bu misolda bitta embed.FS o‘zgaruvchisiga bir nechta pattern berilgan. Uzun qator o‘rniga direktivani takrorlash ham mumkin:

//go:embed templates/*.html
//go:embed static/css/*.css
var content embed.FS

Muhim qoidalar:

  • /static, ../static va C:/static kabi paket tashqarisiga chiquvchi yoki mutlaq yo‘llar taqiqlangan;
  • . bilan joriy katalogni ko‘rsatib bo‘lmaydi, buning uchun * ishlatiladi;
  • har bir pattern kamida bitta fayl yoki bo‘sh bo‘lmagan katalogga mos kelishi kerak, aks holda build xato beradi;
  • symbolic link, .git, vendor va ichida alohida go.mod bo‘lgan katalogdagi fayllarni pattern orqali joylab bo‘lmaydi;
  • fayl nomida bo‘sh joy bo‘lsa, patternni "docs/user guide.txt" kabi qo‘shtirnoq ichida yozish mumkin.

Katalog nomi va * o‘rtasidagi farq

//go:embed assets katalogni rekursiv aylanadi, lekin nomi . yoki _ bilan boshlanadigan fayl va kataloglarni tashlab ketadi. Ularni ham kiritish kerak bo‘lsa, all: prefiksi ishlatiladi:

//go:embed all:assets
var assets embed.FS

//go:embed assets/* esa assets ichidagi birinchi darajadagi yashirin faylga ham mos kelishi mumkin. Lekin ichki katalogni rekursiv aylashda uning yashirin fayllari baribir tashlab ketiladi. Shu nozik farq sababli butun katalog kerak bo‘lsa, odatda katalog nomini yozish aniqroq; yashirin fayllar ham kerak bo‘lsa, all:assets ishlatiladi.

HTML shablon bilan amaliy misol

Backend dasturda HTML shablonni binary ichiga joylash tarqatishni soddalashtiradi. Quyidagi tuzilma mavjud bo‘lsin:

Loyiha tuzilishi
.
├── main.go
└── templates
    └── welcome.html

Shablon:

templates/welcome.html
<h1>Salom, {{.Name}}!</h1>

Dastur:

main.go
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package main

import (
    "embed"
    "html/template"
    "log"
    "os"
)

//go:embed templates/*.html
var templateFiles embed.FS

type PageData struct {
    Name string
}

func main() {
    tmpl, err := template.ParseFS(templateFiles, "templates/*.html")
    if err != nil {
        log.Fatal(err)
    }

    err = tmpl.ExecuteTemplate(os.Stdout, "welcome.html", PageData{Name: "Aziza"})
    if err != nil {
        log.Fatal(err)
    }
}

Natija:

<h1>Salom, Aziza!</h1>

template.ParseFS() shablonni diskdan emas, templateFiles ichidan o‘qiydi. ExecuteTemplate() PageData.Name qiymatini {{.Name}} o‘rniga xavfsiz HTML ko‘rinishida yozadi. Real HTTP serverda os.Stdout o‘rniga http.ResponseWriter beriladi. Shablon sintaksisi xato bo‘lsa, ParseFS() xato qaytaradi; shu sababli xatoni tekshirish zarur.

Statik fayllarni HTTP orqali tarqatishda ko‘pincha binary ichidagi static prefiksini olib tashlash qulay:

staticFS, err := fs.Sub(templateFiles, "static")
if err != nil {
    return err
}

handler := http.FileServer(http.FS(staticFS))

Bu parcha alohida to‘liq dastur emas. fs.Sub() fayl tizimining static ichidan boshlanadigan ko‘rinishini qaytaradi. http.FS() esa io/fs.FSni http.FileServer() tushunadigan shaklga moslaydi. Amalda templateFiles o‘rnida static katalogi embed qilingan embed.FS bo‘lishi kerak.

embed.FS faqat o‘qish uchun

embed.FSda Open, ReadFile va ReadDir metodlari bor, ammo WriteFile, Create yoki Remove yo‘q. Embedded ma’lumot binary tarkibiga kirgani uchun uni runtime vaqtida doimiy o‘zgartirib bo‘lmaydi.

Agar dasturga boshlang‘ich konfiguratsiya kerak bo‘lsa, uni embed qilish mumkin. Foydalanuvchi o‘zgartiradigan konfiguratsiyani esa diskka yoki boshqa tashqi saqlash joyiga yozish kerak. Xuddi shunday, database migratsiyalarini binary ichiga joylash qulay, ammo foydalanuvchi yuklagan fayllarni embed.FSga qo‘shib bo‘lmaydi.

Keng tarqalgan xatolar

embed paketini import qilmaslik

Quyidagi kod build vaqtida go:embed requires import "embed" xatosini beradi, chunki direktiva ishlatilgan fayl embed paketini import qilishi kerak:

// Noto‘g‘ri: bu faylda "embed" import qilinmagan.
//go:embed message.txt
var message string

string yoki []byte bilan _ "embed", embed.FS bilan esa oddiy "embed" importidan foydalaning.

Direktiva bilan o‘zgaruvchini ajratib yuborish

Direktiva bitta o‘zgaruvchi deklaratsiyasiga tegishli. U bilan deklaratsiya orasida boshqa deklaratsiya bo‘lishi mumkin emas:

// Noto‘g‘ri misol.
//go:embed message.txt
const defaultName = "Go"

var message string

Bo‘sh qator va // ko‘rinishidagi izohga ruxsat bor, lekin aniq va o‘qilishi qulay kod uchun direktivani o‘zgaruvchining bevosita ustiga yozing.

Runtime vaqtida tashqi fayl yangilanishini kutish

Embedded konfiguratsiya yoki shablon diskdagi nusxa o‘zgarganda avtomatik yangilanmaydi. Bu production’da barqarorlik beradi, lekin dastur ishlayotgan paytda shablonni almashtirish talab qilinsa, embed mos kelmasligi mumkin. Bunday holatda faylni diskdan o‘qing yoki o‘zgarishdan keyin binary’ni qayta build va deploy qiling.

Xatolarni e’tiborsiz qoldirish

Fayl build vaqtida mavjud bo‘lsa ham, ReadFile()ga noto‘g‘ri yo‘l berish mumkin. Masalan, embed qilingan yo‘l texts/file1.txt bo‘lsa, ReadFile("file1.txt") uni topmaydi. ReadFile, ReadDir, ParseFS va fs.Sub qaytargan xatolarni tekshiring.

Hajm, xotira va xavfsizlik

Embedded fayllar binary hajmini oshiradi. Bir necha kichik shablon yoki migratsiya uchun bu odatda maqbul. Yuzlab megabayt video, arxiv yoki tez-tez yangilanadigan kontent uchun tashqi fayl saqlash tizimi ma’qulroq bo‘lishi mumkin. Katta binary’ni build qilish, uzatish va container image ichida saqlash ko‘proq vaqt va joy talab qiladi.

Embedded fayl sir saqlash vositasi emas. API kalit, parol yoki private key’ni binary ichiga qo‘shish uni xavfsiz qilmaydi: binary’ga kira olgan kishi ma’lumotni ajratib olishi mumkin. Sirlarni environment variable yoki maxsus secret manager orqali bering.

embed build natijasining takrorlanuvchan bo‘lishiga yordam beradi: dastur va uning statik resurslari bitta artefaktda tarqatiladi. Biroq resurs o‘zgarsa, Go build cache natijani yangilashi va yangi binary yaratishi uchun tegishli paket qayta build qilinadi.

Interviewda muhim nuqtalar

  • //go:embed faqat paket darajasidagi string, []byte yoki embed.FS o‘zgaruvchisini boshlang‘ich qiymat bilan to‘ldiradi.
  • string va []byte faqat bitta faylga mos keluvchi bitta patternni qabul qiladi; embed.FS bir nechta patternni qabul qiladi.
  • Pattern direktiva turgan Go faylining paket katalogiga nisbatan hisoblanadi.
  • embed.FS io/fs.FS interfeysini amalga oshiradi va faqat o‘qish uchun mo‘ljallangan.
  • Fayllar runtime’da diskdan olinmaydi. Ular o‘zgarsa, binary’ni qayta kompilyatsiya qilish kerak.
  • embed binary hajmini oshiradi va maxfiy ma’lumotni himoya qilmaydi.

Xulosa

embed statik resurslarni Go dasturi bilan bitta binary sifatida tarqatadi. Bitta matn uchun string, binary ma’lumot uchun []byte, fayllar daraxti uchun embed.FS ishlatiladi. Patternlar paket katalogiga nisbatan yoziladi va ularning har biri build vaqtida mavjud faylga mos kelishi shart.

Real loyihada embed HTML shablonlar, SQL migratsiyalar, CLI yordam matnlari va kichik statik assetlar uchun qulay. Runtime’da o‘zgaradigan yoki maxfiy ma’lumotlarni esa tashqi manbada saqlash kerak.

📍 Toshkent, O'zbekiston
🗓️
👤