</> Softromeda Edu

5-bo‘lim

Shartlar va switch

if va uning boshlang'ich qismi, mantiqiy amallar, switch ning to'rt shakli, fallthrough va erta qaytish uslubi.

🕑 13 daqiqa o‘qish 📄 720 so‘z 👁 0 marta ko‘rilgan
Ushbu bo‘lim mundarijasi
  1. if va else
  2. Boshlang'ich qismli if
  3. Mantiqiy amallar
  4. switch
  5. Shartsiz switch
  6. Boshlang'ich qismli switch
  7. fallthrough
  8. Tur bo'yicha switch
  9. Erta qaytish uslubi
  10. Xulosa

Go da shart tekshirish juda kam qoidadan iborat. Qavslar yo'q, figurali qavslar esa majburiy.

if va else #

Go
package main

import "fmt"

func main() {
    ball := 87

    if ball >= 90 {
        fmt.Println("A'lo")
    } else if ball >= 75 {
        fmt.Println("Yaxshi")
    } else if ball >= 60 {
        fmt.Println("Qoniqarli")
    } else {
        fmt.Println("Qoniqarsiz")
    }
}
Natija
Yaxshi

Shart atrofida qavs yozilmaydi: if (ball >= 90) emas, balki if ball >= 90.

Figurali qavs bir qatorda ochilishi shart

Go da bu kod ishlamaydi:

Go
if ball > 60
{
    fmt.Println("o'tdi")
}

Sabab - Go kompilyatori qator oxiriga nuqtali vergulni o'zi qo'yadi. if ball > 60 dan keyin qator tugasa, u yerga nuqtali vergul qo'yiladi va shart bo'shab qoladi.

Shuning uchun { har doim o'sha qatorda turishi kerak. gofmt buni o'zi to'g'rilaydi.

Boshlang'ich qismli if #

Go
package main

import (
    "fmt"
    "strconv"
)

func main() {
    if son, xato := strconv.Atoi("42"); xato == nil {
        fmt.Println("O'qildi:", son*2)
    }

    if son, xato := strconv.Atoi("salom"); xato != nil {
        fmt.Println("O'qib bo'lmadi, qiymat:", son)
    }
}
Natija
O'qildi: 84
O'qib bo'lmadi, qiymat: 0

if ichida nuqtali vergulgacha bo'lgan qism - boshlang'ich buyruq. U shartdan oldin bajariladi.

Bu yerda e'lon qilingan o'zgaruvchilar faqat shu if va uning else shoxlari ichida yashaydi.

Bu Go dagi eng ko'p uchraydigan shakl

natija, xato := biror_narsa() keyin darhol xato ni tekshirish - Go kodining asosiy ritmi.

Boshlang'ich qismli if bu ikki qadamni bitta qatorga yig'adi va, eng muhimi, xato o'zgaruvchisini funksiyaning qolgan qismidan yashiradi. Shunda uni keyingi joyda tasodifan ishlatib yuborish xavfi yo'qoladi.

Mantiqiy amallar #

Go
package main

import "fmt"

func main() {
    yosh := 25
    shahar := "Namangan"

    fmt.Println(yosh >= 18 && shahar == "Namangan")
    fmt.Println(yosh < 18 || shahar == "Namangan")
    fmt.Println(!(yosh == 25))
}
Natija
true
true
false
AmalMa'nosi
&&Ikkalasi ham rost
||Kamida bittasi rost
!Teskarisi
== / !=Teng / teng emas
< <= > >=Taqqoslash
Qisqa hisoblash

&& va || kerak bo'lmasa hisoblamaydi.

a() && b() da agar a() yolg'on bo'lsa, b() umuman chaqirilmaydi - natija baribir yolg'on.

Bu shunchaki tezlik masalasi emas, balki himoya usuli ham:

Go
if royxat != nil && len(royxat) > 0 {

Bu yerda birinchi tekshiruv o'tmasa, ikkinchisi bajarilmaydi.

switch #

Go
package main

import "fmt"

func main() {
    kun := 3

    switch kun {
    case 1:
        fmt.Println("Dushanba")
    case 2:
        fmt.Println("Seshanba")
    case 3:
        fmt.Println("Chorshanba")
    case 6, 7:
        fmt.Println("Dam olish kuni")
    default:
        fmt.Println("Boshqa kun")
    }
}
Natija
Chorshanba

Go dagi switch da break yozish kerak emas. Har bir case o'z ishini bajaradi va switch tugaydi.

case 6, 7: - bitta shoxda bir nechta qiymat.

C va Java dan farqi

C, Java, JavaScript da break yozilmasa, dastur keyingi shoxga o'tib ketadi. Bu unutilganda topish qiyin xatolarga olib keladi.

Go bu qarorni teskarisiga o'zgartirdi: odatiy holat - to'xtash. O'tkazish kerak bo'lsa, uni fallthrough bilan ochiq yozasiz.

Amalda fallthrough juda kam kerak bo'ladi - buni quyida ko'ramiz.

Shartsiz switch #

Go
package main

import "fmt"

func main() {
    ball := 87

    switch {
    case ball >= 90:
        fmt.Println("A'lo")
    case ball >= 75:
        fmt.Println("Yaxshi")
    case ball >= 60:
        fmt.Println("Qoniqarli")
    default:
        fmt.Println("Qoniqarsiz")
    }
}
Natija
Yaxshi

switch dan keyin hech narsa yozilmasa, u switch true degani bo'ladi va har bir case o'z shartini tekshiradi.

Bu uzun if / else if zanjirining o'rnini bosadi va ancha o'qishliroq ko'rinadi.

Boshlang'ich qismli switch #

Go
package main

import "fmt"

func daraja(ball int) string {
    switch kesim := ball / 10; {
    case kesim >= 9:
        return "A"
    case kesim >= 8:
        return "B"
    case kesim >= 7:
        return "C"
    default:
        return "D"
    }
}

func main() {
    fmt.Println(daraja(95))
    fmt.Println(daraja(83))
    fmt.Println(daraja(71))
    fmt.Println(daraja(42))
}
Natija
A
B
C
D

if dagi kabi, switch ham boshlang'ich buyruq qabul qiladi.

fallthrough #

Go
package main

import "fmt"

func main() {
    daraja := 2

    switch daraja {
    case 3:
        fmt.Println("Hisobot ko'rish")
        fallthrough
    case 2:
        fmt.Println("Tahrirlash")
        fallthrough
    case 1:
        fmt.Println("O'qish")
    }
}
Natija
Tahrirlash
O'qish

fallthrough keyingi shoxga shartini tekshirmasdan o'tadi.

Bu yerda u mantiqan to'g'ri ishlatilgan: 2-daraja 1-darajadagi hamma huquqni o'z ichiga oladi.

fallthrough shartni tekshirmaydi

fallthrough keyingi case ning shartiga umuman qaramaydi - u shunchaki keyingi blokni bajaradi.

Shuning uchun uni darajali huquqlar kabi aniq "zinapoya" holatlarda ishlatish mumkin, boshqa joyda esa u chalkashlik keltiradi.

Yana bir cheklov: fallthrough blokning eng oxirgi buyrug'i bo'lishi kerak.

Tur bo'yicha switch #

Go
package main

import "fmt"

func tavsifla(q any) string {
    switch qiymat := q.(type) {
    case int:
        return fmt.Sprintf("butun son: %d", qiymat*2)
    case string:
        return fmt.Sprintf("satr, uzunligi %d", len(qiymat))
    case bool:
        return fmt.Sprintf("mantiqiy: %t", qiymat)
    case nil:
        return "hech narsa"
    default:
        return fmt.Sprintf("noma'lum tur: %T", qiymat)
    }
}

func main() {
    fmt.Println(tavsifla(21))
    fmt.Println(tavsifla("Namangan"))
    fmt.Println(tavsifla(true))
    fmt.Println(tavsifla(nil))
    fmt.Println(tavsifla(3.14))
}
Natija
butun son: 42
satr, uzunligi 8
mantiqiy: true
hech narsa
noma'lum tur: float64

q.(type) - faqat switch ichida ishlatiladigan maxsus shakl. Har bir shoxda qiymat o'zgaruvchisi aynan o'sha turga ega bo'ladi, shuning uchun uni darhol ishlatish mumkin.

Buni 13-bo'limda, interfeyslar bilan birga chuqurroq ko'ramiz.

Erta qaytish uslubi #

Go
package main

import (
    "fmt"
    "strings"
)

func tekshir(parol string) string {
    if len(parol) < 8 {
        return "Juda qisqa"
    }
    if strings.ToLower(parol) == parol {
        return "Katta harf kerak"
    }
    if !strings.ContainsAny(parol, "0123456789") {
        return "Raqam kerak"
    }
    return "Kuchli"
}

func main() {
    fmt.Println(tekshir("abc"))
    fmt.Println(tekshir("abcdefghij"))
    fmt.Println(tekshir("Abcdefghij"))
    fmt.Println(tekshir("Abcdefgh1"))
}
Natija
Juda qisqa
Katta harf kerak
Raqam kerak
Kuchli
Go uslubi - chapga yopishgan kod

Bu funksiyani ichma-ich if / else bilan ham yozish mumkin edi, lekin shunda har bir shart bir qadam o'ngga surilardi.

Go jamoasi boshqa yo'lni tanlaydi: muammoli holatni darhol qaytar, keyin davom et. Natijada "baxtli yo'l" har doim eng chapda, oxirida turadi.

Ko'p Go kodini o'qiganingizda, bu shaklni doim ko'rasiz:

Go
if xato != nil {
    return xato
}

Uni qo'riqchi shart (guard clause) deb atashadi.

Amaliy topshiriq
  1. Ballni bahoga aylantiruvchi if / else if zanjirini yozing.
  2. Xuddi shuni shartsiz switch bilan qayta yozing.
  3. if ning boshlang'ich qismida strconv.Atoi ni ishlating.
  4. && va || ni bitta shartda birga ishlating.
  5. Qisqa hisoblash ishlashini isbotlang.
  6. case da bir nechta qiymat yozib ko'ring.
  7. fallthrough bilan darajali huquqlarni chiqaring.
  8. switch ga boshlang'ich buyruq qo'shing.
  9. Tur bo'yicha switch yozib, to'rt turni ajrating.
  10. Qo'riqchi shartlar bilan parol tekshiruvchi yozing.

Xulosa #

  • Shart atrofida qavs yo'q, figurali qavs esa majburiy va o'sha qatorda ochiladi.
  • if va switch boshlang'ich buyruq qabul qiladi; unda e'lon qilingan o'zgaruvchi faqat shu blok ichida yashaydi.
  • && va || qisqa hisoblaydi - kerak bo'lmasa, o'ng tomon bajarilmaydi.
  • switch da break kerak emas; o'tkazish uchun fallthrough ochiq yoziladi.
  • Shartsiz switch uzun if / else if zanjirining o'rnini bosadi.
  • q.(type) bilan tur bo'yicha switch yozish mumkin.
  • Go uslubi - erta qaytish: muammoli holatni darhol qaytarib, asosiy kodni chapda qoldirish.

Keyingi bo'limda sikllarni o'rganamiz.

Xatolik topdingizmi?

Imlo xatosi, ishlamaydigan kod yoki noto‘g‘ri ma‘lumotni ko‘rsangiz - bizga xabar bering. Har bir xabar administrator tomonidan ko‘rib chiqiladi.