Go’da if, else if va else shartlari

Dastur har doim bir xil buyruqlarni bajaravermaydi. Ba’zan qiymat yoki holatga qarab turli yo‘nalishlardan birini tanlashi kerak. Masalan, foydalanuvchi voyaga yetgan bo‘lsa tizimga kirishga ruxsat berish, aks holda rad etish mumkin.

Kodning shartga qarab turli yo‘nalishda bajarilishi tarmoqlanish (branching) deyiladi. Go’da bunday tarmoqlanish if, else if va else yordamida yoziladi.

if sharti

if berilgan mantiqiy ifodani tekshiradi. Ifoda true bo‘lsa, { va } orasidagi kod bajariladi. false bo‘lsa, blok o‘tkazib yuboriladi.

if mantiqiyIfoda {
    // Shart true bo‘lsa, bu kod bajariladi.
}

Masalan:

package main

import "fmt"

func main() {
    harorat := 32

    if harorat > 30 {
        fmt.Println("Bugun havo issiq.")
    }
}

harorat > 30 taqqoslashining natijasi true, shuning uchun xabar ekranga chiqadi. harorat qiymati 25 bo‘lsa, if bloki bajarilmaydi.

Info

Go’da if sharti atrofida qavs yozish shart emas. Jingalak qavslar esa majburiy, blokda faqat bitta buyruq bo‘lsa ham yoziladi.

Shart bool bo‘lishi kerak

if ichidagi ifoda bool, ya’ni true yoki false qiymat qaytarishi kerak:

yosh := 20
if yosh >= 18 {
    fmt.Println("Voyaga yetgan")
}

Go boshqa ayrim tillardagi kabi 0ni false, boshqa sonlarni true deb qabul qilmaydi:

son := 1
// if son { } // kompilyatsiya xatosi: son bool emas

Sonni aniq taqqoslash kerak:

if son != 0 {
    fmt.Println("Son nol emas")
}

Foydalanuvchi yoshini tekshirish

Konsoldan yosh olib, foydalanuvchi 18 yoshdan katta bo‘lsa xabar chiqaramiz:

package main

import "fmt"

func main() {
    var yosh int

    fmt.Print("Yoshingizni kiriting: ")
    _, err := fmt.Scan(&yosh)
    if err != nil {
        fmt.Println("Xato: yoshni butun son bilan kiriting.")
        return
    }

    if yosh > 18 {
        fmt.Println("Xush kelibsiz!")
    }
}

19 kiritilsa:

Yoshingizni kiriting: 19
Xush kelibsiz!

18 kiritilsa, xabar chiqmaydi. Sababi 18 > 18 ifodasi false. Agar 18 yosh ham ruxsat etilgan bo‘lsa, katta yoki teng operatori ishlatiladi:

if yosh >= 18 {
    fmt.Println("Xush kelibsiz!")
}

Chegaraviy qiymatni aniq tanlash muhim:

• yosh > 18 — faqat 19 va undan katta qiymatlar;
• yosh >= 18 — 18 hamda undan katta qiymatlar;
• yosh < 18 — 18 dan kichik qiymatlar;
• yosh <= 18 — 18 hamda undan kichik qiymatlar.

else: aks holda

Faqat if ishlatilsa, shart false bo‘lganida hech qanday muqobil kod bajarilmaydi. Xabarni if blokidan keyin oddiy yozish ham muammoni hal qilmaydi:

if yosh >= 18 {
    fmt.Println("Xush kelibsiz!")
}

fmt.Println("Mumkin emas!")

Bu kodda Mumkin emas! har doim chiqadi. Yosh 20 bo‘lsa, ikkala xabar ham ko‘rinadi, chunki ikkinchi Println() hech qanday shart ichida emas.

Ikki yo‘nalishdan aynan bittasini bajarish uchun else ishlatiladi:

if mantiqiyIfoda {
    // Shart true bo‘lsa bajariladi.
} else {
    // Shart false bo‘lsa bajariladi.
}

Yosh misolini else bilan to‘ldiramiz:

package main

import "fmt"

func main() {
    var yosh int

    fmt.Print("Yoshingizni kiriting: ")
    _, err := fmt.Scan(&yosh)
    if err != nil {
        fmt.Println("Xato: yoshni butun son bilan kiriting.")
        return
    }

    if yosh >= 18 {
        fmt.Println("Xush kelibsiz!")
    } else {
        fmt.Println("Mumkin emas!")
    }
}

15 kiritilsa:

Yoshingizni kiriting: 15
Mumkin emas!

18 kiritilsa:

Yoshingizni kiriting: 18
Xush kelibsiz!

if va else bloklaridan faqat bittasi bajariladi. Shart true bo‘lsa if, aks holda else ishlaydi.

Warning

Go’da else yopuvchi } bilan bir qatorda yoziladi: } else {. elseni keyingi qatorga tushirish avtomatik nuqtali vergul qoidasi sababli sintaksis xatosiga olib keladi.

else if: bir nechta holat

Ba’zan ikkita emas, bir nechta holatdan birini tanlash kerak. else if qo‘shimcha shartlarni ketma-ket tekshiradi:

if birinchiShart {
    // Birinchi shart true bo‘lsa bajariladi.
} else if ikkinchiShart {
    // Birinchi false, ikkinchi true bo‘lsa bajariladi.
} else if uchinchiShart {
    // Oldingi shartlar false, uchinchi true bo‘lsa bajariladi.
} else {
    // Hech bir shart true bo‘lmasa bajariladi.
}

Go shartlarni yuqoridan pastga tekshiradi. Birinchi true shartning bloki bajarilgach, qolgan else if va else qismlari tekshirilmaydi.

package main

import "fmt"

func main() {
    var yosh int

    fmt.Print("Yoshingizni kiriting: ")
    _, err := fmt.Scan(&yosh)
    if err != nil {
        fmt.Println("Xato: yoshni butun son bilan kiriting.")
        return
    }

    if yosh >= 30 {
        fmt.Println("Siz 30 yosh yoki undan kattasiz.")
    } else if yosh >= 18 {
        fmt.Println("Xush kelibsiz!")
    } else {
        fmt.Println("Mumkin emas!")
    }
}

Natijalar:

• 35 kiritilsa, birinchi xabar chiqadi;
• 22 kiritilsa, Xush kelibsiz! chiqadi;
• 15 kiritilsa, Mumkin emas! chiqadi.

Bu yerda oraliqlar quyidagicha taqsimlanadi:

Yosh	Bajariladigan blok
30 va undan katta	if yosh >= 30
18 dan 29 gacha	else if yosh >= 18
18 dan kichik	else

Ikkinchi shartda yosh < 30 deb yozish shart emas. Dastur shu qatorga kelgan bo‘lsa, birinchi yosh >= 30 sharti allaqachon false bo‘lgan.

Shartlar tartibi muhim

Kengroq shartni oldin yozish keyingi aniqroq shartni yopib qo‘yishi mumkin:

if yosh >= 18 {
    fmt.Println("18 yoki undan katta")
} else if yosh >= 30 {
    fmt.Println("30 yoki undan katta")
}

Bu kodda yosh >= 30 bloki hech qachon bajarilmaydi. Masalan, 35 birinchi yosh >= 18 shartiga mos keladi va tekshiruv shu yerda tugaydi.

To‘g‘ri tartib — aniqroq yoki yuqori chegarali shartni oldin yozish:

if yosh >= 30 {
    fmt.Println("30 yoki undan katta")
} else if yosh >= 18 {
    fmt.Println("18 dan 29 gacha")
}

Shartlar oralig‘ini qog‘ozda yoki jadvalda ajratib olish takrorlangan va yetib bo‘lmaydigan holatlarni ko‘rishga yordam beradi.

Mantiqiy operatorlar bilan murakkab shart

&&, || va ! operatorlari yordamida bir nechta tekshiruvni bitta shartga birlashtirish mumkin.

&&: barcha shartlar bajarilishi kerak

package main

import "fmt"

func main() {
    yosh := 24
    chiptasiBor := true

    if yosh >= 18 && chiptasiBor {
        fmt.Println("Tadbirga kirishingiz mumkin.")
    } else {
        fmt.Println("Kirish uchun yosh va chipta talabi bajarilishi kerak.")
    }
}

&& ishlatilganda ikkala shart ham true bo‘lishi kerak.

||: shartlardan bittasi yetarli

damOlishKuni := true
tatil := false

if damOlishKuni || tatil {
    fmt.Println("Bugun dam olish mumkin.")
}

|| ishlatilganda kamida bitta shart true bo‘lsa, blok bajariladi.

!: qiymatni inkor qilish

bloklangan := false

if !bloklangan {
    fmt.Println("Foydalanuvchi faol.")
}

!bloklangan qiymati bloklangan == false bilan bir xil ma’noni beradi, ammo ko‘pincha qisqaroq o‘qiladi.

Qiymat oralig‘ini tekshirish

Son ma’lum oraliqda ekanini tekshirish amaliy dasturlarda ko‘p uchraydi. Masalan, imtihon bali 0 dan 100 gacha bo‘lishi kerak:

package main

import "fmt"

func main() {
    var ball int

    fmt.Print("Natijani kiriting: ")
    _, err := fmt.Scan(&ball)
    if err != nil {
        fmt.Println("Xato: butun son kiriting.")
        return
    }

    if ball < 0 || ball > 100 {
        fmt.Println("Xato: natija 0 dan 100 gacha bo‘lishi kerak.")
    } else if ball >= 86 {
        fmt.Println("A’lo")
    } else if ball >= 71 {
        fmt.Println("Yaxshi")
    } else if ball >= 56 {
        fmt.Println("Qoniqarli")
    } else {
        fmt.Println("Qoniqarsiz")
    }
}

Avval noto‘g‘ri oraliq tekshirildi. Keyin baholar yuqoridan pastga qarab joylashtirildi. Masalan, 90 birinchi baholash shartiga mos keladi; 75 birinchisidan o‘tmay, ikkinchisiga mos keladi.

Ichma-ich if

Bir if blokining ichida boshqa if yozish mumkin. Bu ichma-ich shart (nested if) deyiladi:

package main

import "fmt"

func main() {
    tizimgaKirdi := true
    admin := false

    if tizimgaKirdi {
        fmt.Println("Shaxsiy sahifa ochildi.")

        if admin {
            fmt.Println("Boshqaruv paneli ochildi.")
        }
    } else {
        fmt.Println("Avval tizimga kiring.")
    }
}

Ichki if admin faqat tashqi tizimgaKirdi sharti true bo‘lganda tekshiriladi.

Ichma-ich bloklar ko‘payib ketsa, kodni o‘qish qiyinlashadi. Oddiy mantiqiy operator yoki erta return bilan tuzilmani soddalashtirish mumkin.

if ichida qisqa e’lon

Go if shartidan oldin qisqa buyruq yozishga ruxsat beradi. Buyruq va shart nuqtali vergul bilan ajratiladi:

package main

import "fmt"

func main() {
    sonlar := []int{12, 8, 5}

    if soni := len(sonlar); soni > 0 {
        fmt.Println("Elementlar soni:", soni)
    } else {
        fmt.Println("To‘plam bo‘sh.")
    }
}

soni := len(sonlar) avval bajariladi, keyin soni > 0 tekshiriladi. Bu yerda slice faqat misol uchun ishlatilgan; slice mavzusi keyinroq batafsil o‘rganiladi.

Qisqa e’londa yaratilgan o‘zgaruvchi faqat if, unga bog‘langan else if va else bloklarida ko‘rinadi:

if son := 10; son > 0 {
    fmt.Println(son)
}

// fmt.Println(son) // bu yerda son ko‘rinmaydi

Bu usul vaqtinchalik natija faqat shart ichida kerak bo‘lganda qulay. Masalan, funksiya qaytargan errni tekshirishda ko‘p ishlatiladi.

Blok va ko‘rinish sohasi

if ichida e’lon qilingan o‘zgaruvchi shu blokdan tashqarida ko‘rinmaydi:

yosh := 20

if yosh >= 18 {
    xabar := "Xush kelibsiz"
    fmt.Println(xabar)
}

// fmt.Println(xabar) // kompilyatsiya xatosi

xabar faqat ifning {} bloki ichida mavjud. Agar qiymat blokdan keyin ham kerak bo‘lsa, o‘zgaruvchini ifdan oldin e’lon qilish kerak:

xabar := "Mumkin emas"

if yosh >= 18 {
    xabar = "Xush kelibsiz"
}

fmt.Println(xabar)

Erta return bilan kodni soddalashtirish

Xato holatlarni boshida tekshirib, funksiyani darhol tugatish ichma-ich bloklarni kamaytiradi:

package main

import "fmt"

func main() {
    var yosh int

    fmt.Print("Yoshingizni kiriting: ")
    _, err := fmt.Scan(&yosh)
    if err != nil {
        fmt.Println("Xato: butun son kiriting.")
        return
    }

    if yosh < 0 || yosh > 150 {
        fmt.Println("Xato: yosh 0 dan 150 gacha bo‘lishi kerak.")
        return
    }

    if yosh < 18 {
        fmt.Println("Mumkin emas!")
        return
    }

    fmt.Println("Xush kelibsiz!")
}

Har bir noto‘g‘ri holat tekshirilgach, return main()ni tugatadi. Asosiy muvaffaqiyatli yo‘l esa ortiqcha else va chuqur ichma-ich bloklarsiz pastda qoladi. Bu usul guard clause deb ham ataladi.

Mustaqil iflar va else if zanjiri farqi

Bir nechta mustaqil if ishlatilsa, bir nechta blok bajarilishi mumkin:

son := 12

if son > 0 {
    fmt.Println("Musbat")
}

if son%2 == 0 {
    fmt.Println("Juft")
}

Natijada Musbat ham, Juft ham chiqadi. Chunki ikkala shart alohida tekshiriladi.

if–else if–else zanjirida esa faqat birinchi mos blok bajariladi:

if son < 0 {
    fmt.Println("Manfiy")
} else if son == 0 {
    fmt.Println("Nol")
} else {
    fmt.Println("Musbat")
}

Bir nechta xususiyat bir vaqtda tekshirilsa mustaqil iflar, bir-birini istisno qiladigan holatlardan bittasi tanlansa else if zanjiri mos keladi.

Keng uchraydigan xatolar

= va ==ni adashtirish

= qiymat beradi, == tenglikni tekshiradi:

yosh := 18

if yosh == 18 {
    fmt.Println("Yosh 18 ga teng")
}

Go’da if yosh = 18 shart sifatida ishlamaydi.

Chegarani noto‘g‘ri tanlash

Talab “18 va undan katta” bo‘lsa, > emas, >= kerak. 17, 18 va 19 kabi chegara atrofidagi qiymatlar mantiqni tekshirishga yordam beradi.

Yetib bo‘lmaydigan shart

Keng shartni aniq shartdan oldin yozmang:

// Noto‘g‘ri tartib:
if ball >= 56 {
    fmt.Println("O‘tdi")
} else if ball >= 86 {
    fmt.Println("A’lo") // bu blok bajarilmaydi
}

86 va undan yuqori ball birinchi shartga ham mos keladi. Shu sababli ball >= 86 oldin yozilishi kerak.

Kiritish xatosini e’tiborsiz qoldirish

fmt.Scan(&yosh) natijasini tekshirmaslik matn yoki noto‘g‘ri format kiritilganda dastur nol qiymat bilan davom etishiga sabab bo‘lishi mumkin. Tashqaridan kelgan qiymatning turi va ruxsat etilgan oralig‘ini doim tekshiring.

Xulosa

if shart true bo‘lganda blokni bajaradi. else shart false bo‘lgandagi muqobil yo‘lni, else if esa qo‘shimcha holatlarni ifodalaydi. Shartlar yuqoridan pastga tekshiriladi va zanjirdagi birinchi mos blok bajariladi. Chegaralar, shartlar tartibi va kiritilgan qiymatni tekshirish dastur mantiqining to‘g‘ri ishlashi uchun muhim.

Keyingi darsda bir qiymatni bir nechta aniq variant bilan solishtirish uchun switch operatoridan foydalanamiz.