# Xatolarni boshqarish (Error Handling) ## Nima uchun Go'da try-catch yo'q? Python va Java'da xato uchishi bilan kod "sakrab" ketadi — catch blokka. Sakrash qayerga borishi ko'rinmaydi. Bu yashirin kontrol oqim: siz funksiya ichida qayerda exception uchishi mumkinligini bilmaysiz. Go'da xato — oddiy o'zgaruvchi. Funksiya `(natija, error)` qaytaradi, siz darhol tekshirasiz: ```go // Java / Python uslubi — Go'da YO'Q try { result = riskyOperation() // Bu yerda exception uchishi mumkin // QAYERDA uchishi — noma'lum } catch (Exception e) { handle(e) } // Go uslubi — aniq va ko'rinadigan result, err := riskyOperation() if err != nil { // Aynan SHU QATORDA xato bo'ldi — aniq return fmt.Errorf("amalni bajarib bo'lmadi: %w", err) } ``` `err != nil` qatorida aynan qayerda xato bo'lganini bilasiz. Rob Pike buni shunday tushuntiradi: > "Xatolar — qiymatlar. Qiymatlarni dasturlash mumkin." Ya'ni xato — birinchi darajali ob'ekt. Uni log qilish, wrap qilish, qayta qayta ishlash mumkin — exception kabi "uchib ketmaydi". Pentest kodida bu muhim: tarmoq har doim xato berishi mumkin — server off, port yopiq, timeout. Har bir bunday holat aniq boshqarilishi kerak. ## error interface Go'da `error` — bitta metodli interfeys: ```go type error interface { Error() string } ``` Har qanday tur `Error() string` metodini implement qilsa, u `error` hisoblanadi. Bu soddalik Go'ning kuchida. Funksiyalar odatda ikki qiymat qaytaradi — natija va xato: ```go func divide(a, b float64) (float64, error) { if b == 0 { return 0, errors.New("nolga bo'lish mumkin emas") } return a / b, nil // nil — xato yo'q } result, err := divide(10, 2) if err != nil { fmt.Println("Xato:", err) return } fmt.Println("Natija:", result) // 5 ``` Xato yo'qligida `nil` qaytariladi. `err != nil` — xato bor degani. ## errors.New va fmt.Errorf **errors.New** — oddiy, o'zgarmas xato xabari uchun: ```go import "errors" // Sentinel errors — global, bir marta yaratiladi, ko'p marta ishlatiladi var ( ErrNotFound = errors.New("topilmadi") ErrUnauthorized = errors.New("ruxsat yo'q") ErrInvalidInput = errors.New("noto'g'ri kiritma") ErrTimeout = errors.New("vaqt tugadi") ) func getUser(id int) (User, error) { if id <= 0 { return User{}, ErrInvalidInput // tayyor xatoni qaytarish } // ... return User{}, ErrNotFound } ``` Sentinel errors foydali — `if err == ErrNotFound` yoki `errors.Is(err, ErrNotFound)` bilan tekshirish mumkin. **fmt.Errorf** — dinamik ma'lumot bilan xato yaratish: ```go func connectToServer(host string, port int) error { // Xatoda qaysi host va port ko'rsatiladi return fmt.Errorf("%s:%d ga ulanib bo'lmadi", host, port) } err := connectToServer("192.168.1.1", 8080) fmt.Println(err) // 192.168.1.1:8080 ga ulanib bo'lmadi ``` **%w** — asl xatoni "o'rab olish" (wrap). Bu `errors.Is` va `errors.As` uchun kerak: ```go func readConfig(filename string) error { f, err := os.Open(filename) if err != nil { // %w — asl xato saqlanadi, lekin context qo'shiladi return fmt.Errorf("config o'qib bo'lmadi: %w", err) } defer f.Close() // ... return nil } // Xato zanjiri hosil bo'ladi: // "config o'qib bo'lmadi: open config.json: no such file or directory" // Uch qavatli: bizning xato → OS xatosi → tizim xatosi ``` > [!WARNING] > `%v` asl xatoni yo'qotadi — faqat matnni saqlaydi. `%w` asl xatoni saqlaydi — `errors.Unwrap()` orqali olish mumkin. Xatoni wrap qilayotganda har doim `%w` ishlatish odat qiling. ## Custom error turlari Ba'zan xato haqida qo'shimcha ma'lumot kerak bo'ladi — qaysi host, qaysi port, qayta urinish mumkinmi. Buning uchun custom struct: ```go type NetworkError struct { Host string // Tekshirilayotgan host Port int // Tekshirilayotgan port Operation string // "dial", "read", "write" — qaysi amal xato berdi Err error // Asl xato — wrap qilinadi Retryable bool // Qayta urinish mumkinmi? } // error interface implement qilish — Error() string metodi bo'lishi shart func (e *NetworkError) Error() string { return fmt.Sprintf("%s %s:%d — xato: %v (qayta urinish: %t)", e.Operation, e.Host, e.Port, e.Err, e.Retryable) } // errors.Is va errors.As uchun Unwrap kerak // Bu funksiya asl xatoni qaytaradi — zanjirda qidirish uchun func (e *NetworkError) Unwrap() error { return e.Err } ``` Ishlatish: ```go func connectToTarget(host string, port int) error { conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", host, port)) if err != nil { return &NetworkError{ Host: host, Port: port, Operation: "dial", Err: err, // Asl OS xatosini saqlaymiz Retryable: true, // Network xatolar ko'pincha vaqtinchalik } } conn.Close() return nil } ``` Custom xato tuzilishi: ```go err := connectToTarget("192.168.1.1", 80) fmt.Println(err) // dial 192.168.1.1:80 — xato: connection refused (qayta urinish: true) ``` ## errors.Is va errors.As Wrap qilingan xatoni `==` bilan solishtirish ishlamaydi — zanjir ichida qidirish kerak: ```go var ErrNotFound = errors.New("topilmadi") func getResource(id int) error { // ErrNotFound ni wrap qilamiz — context qo'shamiz return fmt.Errorf("resurs %d: %w", id, ErrNotFound) } err := getResource(123) // ❌ Ishlamaydi — wrap qilingandan keyin == solishtirib bo'lmaydi if err == ErrNotFound { fmt.Println("Bu chiqmaydi") } // ✅ Xato zanjirida qidiradi — ishlaydi if errors.Is(err, ErrNotFound) { fmt.Println("Topilmadi") } ``` `errors.Is` xato zanjiridagi har bir qavatni tekshiradi — `Unwrap()` orqali pastga tushadi. **errors.As** — custom xato turini ajratib olish: ```go err := connectToTarget("192.168.1.1", 80) // errors.As — xato zanjirida NetworkError turini qidiradi var netErr *NetworkError if errors.As(err, &netErr) { fmt.Printf("Host: %s, Port: %d\n", netErr.Host, netErr.Port) if netErr.Retryable { // Qayta urinish logikasi... fmt.Println("Qayta urinish mumkin") } } ``` Ikkalasining farqi: | | `errors.Is` | `errors.As` | |---|---|---| | Nima qiladi? | Aniq qiymatni zanjirda qidiradi | Turni zanjirda qidiradi, ajratib oladi | | Qachon? | Sentinel error tekshirish uchun | Custom metadata kerak bo'lganda | | Misol | `errors.Is(err, ErrNotFound)` | `errors.As(err, &netErr)` | ## Xato handling pattern'lari ### Early return — erta qaytish Xatoni darhol handle qilib, yuqoriga return qiling. Nested `if`lardan qochish: ```go func processRequest(req Request) error { // Har bir qadam xato berishi mumkin // Xato bo'lsa — darhol qaytamiz, qolgan kod bajarilmaydi if err := validateRequest(req); err != nil { return fmt.Errorf("validatsiya: %w", err) } user, err := authenticate(req.Token) if err != nil { return fmt.Errorf("autentifikatsiya: %w", err) } if err := checkPermissions(user, req.Resource); err != nil { return fmt.Errorf("ruxsat tekshiruvi: %w", err) } if err := executeOperation(req, user); err != nil { return fmt.Errorf("bajarish: %w", err) } return nil // Hammasi muvaffaqiyatli } ``` Bu yondashuv kodni "chapga siljishdan" saqlaydi — kod vertikal pastga o'qiladi, chuqurlasha bormaydi. ### Retry — qayta urinish Network xatolari vaqtinchalik bo'lishi mumkin. Exponential backoff bilan qayta urinish: ```go func retryOperation(op func() error, maxRetries int) error { var lastErr error for i := 0; i < maxRetries; i++ { if err := op(); err == nil { return nil // Muvaffaqiyatli! } else { lastErr = err } // Qayta urinish mumkin emas degan xato — darhol qaytamiz var netErr *NetworkError if errors.As(lastErr, &netErr) && !netErr.Retryable { return lastErr } // Exponential backoff: 1s, 2s, 4s, 8s... // 1 << 0 = 1, 1 << 1 = 2, 1 << 2 = 4 wait := time.Duration(1< 65535 { return fmt.Errorf("%w: %d", ErrInvalidPort, port) } return nil } // scanPort — portni tekshiradi, xato bo'lsa ScanError wrap qilib qaytaradi func scanPort(ip string, port int, timeout time.Duration) error { // Early return pattern — validatsiya if err := validateIP(ip); err != nil { return err } if err := validatePort(port); err != nil { return err } // TCP ulanishga urinish addr := fmt.Sprintf("%s:%d", ip, port) conn, err := net.DialTimeout("tcp", addr, timeout) if err != nil { // ScanError yaratamiz — qo'shimcha ma'lumot bilan scanErr := &ScanError{ IP: ip, Port: port, Err: err, Timestamp: time.Now(), } // Timeout ekanligini tekshirish — net.Error interface orqali if netErr, ok := err.(net.Error); ok && netErr.Timeout() { scanErr.Err = ErrTimeout // sentinel error bilan almashtiramiz } return scanErr } // Ochiq port — ulanishni yopamiz conn.Close() return nil // Xato yo'q — port ochiq } func main() { // Turli xil test holatlari testCases := []struct { ip string port int }{ {"192.168.1.1", 80}, // Muvaffaqiyatli bo'lishi yoki timeout {"noto'g'ri_ip", 80}, // IP validatsiya xatosi {"192.168.1.1", 99999}, // Port validatsiya xatosi {"scanme.nmap.org", 22}, // Real server — SSH ochiq bo'lishi kerak } for _, tc := range testCases { err := scanPort(tc.ip, tc.port, 2*time.Second) if err == nil { fmt.Printf("Ochiq: %s:%d\n", tc.ip, tc.port) continue } // Xato turini aniqlash — errors.Is va errors.As switch { case errors.Is(err, ErrInvalidIP): // Sentinel xato — IP format noto'g'ri fmt.Printf("Xato IP: %v\n", err) case errors.Is(err, ErrInvalidPort): // Sentinel xato — Port diapazoni noto'g'ri fmt.Printf("Xato port: %v\n", err) case errors.Is(err, ErrTimeout): // Timeout xatosi — network muammosi bo'lishi mumkin fmt.Printf("Timeout: %v\n", err) default: // Custom ScanError — metadata ajratib olish var scanErr *ScanError if errors.As(err, &scanErr) { fmt.Printf("Ulanib bo'lmadi: %v\n", scanErr) } else { fmt.Printf("Noma'lum xato: %v\n", err) } } } } ``` Bu kodni ishga tushirganda quyidagicha natija ko'rinadi: ``` Ulanib bo'lmadi: [14:30:22] 192.168.1.1:80 — connection refused Xato IP: noto'g'ri IP manzil: noto'g'ri_ip Xato port: noto'g'ri port raqam: 99999 Ochiq: scanme.nmap.org:22 ``` Har bir xato turi alohida ko'rsatiladi — debug qilish osonlashadi. ## Yaxshi xato xabarlari — qoidalar Xato xabarini yozishda uchta savol: - Nima qilayotgan eding? - Qayerda xato bo'ldi? - Nima uchun xato bo'ldi? ```go // Yomon — context yo'q return errors.New("xato") return errors.New("nimadir noto'g'ri") // Yaxshi — aniq va ma'lumotli return fmt.Errorf("%s:%d ga TCP ulanishda xato: %w", host, port, err) return fmt.Errorf("%s faylini o'qib bo'lmadi: %w", filename, err) ``` Xatoni hech qachon ignore qilmang: ```go // Yomon — xato yo'qoladi, dastur noto'g'ri holda ishlaydi result, _ := dangerousOperation() // Yaxshi result, err := dangerousOperation() if err != nil { return fmt.Errorf("amalni bajarib bo'lmadi: %w", err) } ``` Xatoni yuqoriga uzatayotganda context qo'shing: ```go // Yomon — caller bilmaydi nima bo'ldi if err != nil { return err } // Yaxshi — har qavatda context if err != nil { return fmt.Errorf("foydalanuvchi %d ni yangilashda: %w", userID, err) } ``` Zanjir quyidagicha ko'rinadi: ``` foydalanuvchi 42 ni yangilashda: ma'lumotlar bazasiga so'rov: ulanish rad etildi ``` ## Qisqacha — eslab qoling 1. Go'da `try-catch` yo'q — `(result, error)` return pattern. 2. **Sentinel errors** — `errors.New` bilan global o'zgaruvchilar, ko'p marta ishlatiladi. 3. **fmt.Errorf + %w** — xatoni context bilan wrap qiladi, asl xato saqlanadi. 4. **Custom error struct** — qo'shimcha ma'lumot saqlash uchun, `Error()` va `Unwrap()` metodlari. 5. **errors.Is** — wrap qilingan zanjirda sentinel qidiradi. 6. **errors.As** — wrap qilingan zanjirda custom tur qidiradi, ajratib oladi. 7. **Early return** — xatoni darhol handle qilib, nested `if`lardan qochish. 8. **panic** — kutilmagan, tuzatib bo'lmaydigan holatlar uchun. Oddiy xato uchun `error` qaytaring. ## Keyingi qadam Modul 2 ning oxirgi darsida JSON, XML, YAML bilan ishlashni ko'ramiz — API'lardan javob qabul qilish, config fayllarni o'qish va skaner natijalarini saqlash uchun.

Xatolarni Boshqarish (Error Handling): Go'ning Aqlli Yondashuvi