</> Softromeda Edu

6-bo‘lim

Sikllar

for ning to'rt shakli, range bilan yurish, son bo'yicha sikl, break va continue, yorliqlar hamda ichma-ich sikllar.

🕑 15 daqiqa o‘qish 📄 751 so‘z 👁 0 marta ko‘rilgan
Ushbu bo‘lim mundarijasi
  1. Klassik shakl
  2. while shakli
  3. Cheksiz sikl
  4. Son bo'yicha sikl
  5. range bilan yurish
  6. Faqat indeks kerak bo'lsa
  7. break va continue
  8. Yorliqlar
  9. Ichma-ich sikllar
  10. Sikl - ifoda emas
  11. Amaliy misol
  12. Xulosa

Go da bitta sikl kalit so'zi bor: for. while, do-while, foreach - hech biri yo'q.

Ularning o'rniga for bir necha shaklda yoziladi.

Klassik shakl #

Go
package main

import "fmt"

func main() {
    jami := 0
    for i := 1; i <= 5; i++ {
        jami += i
    }
    fmt.Println("Yig'indi:", jami)
}
Natija
Yig'indi: 15

Uch qism: boshlang'ich holat, shart, qadam. Ular orasida nuqtali vergul, atrofida esa qavs yo'q.

while shakli #

Go
package main

import "fmt"

func main() {
    qoldiq := 100

    for qoldiq > 0 {
        qoldiq -= 30
    }
    fmt.Println("Qoldiq:", qoldiq)

    son := 1
    for son < 100 {
        son *= 2
    }
    fmt.Println("Birinchi 100 dan katta daraja:", son)
}
Natija
Qoldiq: -20
Birinchi 100 dan katta daraja: 128

Faqat shart qoldirilsa, for xuddi boshqa tillardagi while kabi ishlaydi.

Nega Go da while yo'q

Go jamoasi tilga har bir kalit so'zni qo'shishdan oldin "busiz ham bo'ladimi?" deb so'raydi.

for shart { } allaqachon while ning aynan o'zi. Alohida kalit so'z qo'shish tilni kattalashtiradi, lekin yangi imkoniyat bermaydi.

Aynan shu mulohaza tufayli Go da atigi 25 ta kalit so'z bor.

Cheksiz sikl #

Go
package main

import "fmt"

func main() {
    hisob := 0

    for {
        hisob++
        if hisob >= 3 {
            break
        }
    }
    fmt.Println("Sikl", hisob, "marta aylandi")
}
Natija
Sikl 3 marta aylandi

for { } - shartsiz sikl. Undan chiqish uchun break yoki return kerak.

Bu shakl serverlarda juda ko'p ishlatiladi: dastur to'xtatilmaguncha so'rovlarni qabul qilib turadi.

Son bo'yicha sikl #

Go
package main

import "fmt"

func main() {
    kvadratlar := []int{}
    for i := range 5 {
        kvadratlar = append(kvadratlar, i*i)
    }
    fmt.Println(kvadratlar)

    hisob := 0
    for range 3 {
        hisob++
    }
    fmt.Println("Takrorlandi:", hisob)
}
Natija
[0 1 4 9 16]
Takrorlandi: 3

for i := range 5 - 0 dan 4 gacha yuradi. Bu shakl Go 1.22 da qo'shilgan va eng qisqa yozuvni beradi.

O'zgaruvchi kerak bo'lmasa, for range 3 deb yozish mumkin - shunchaki uch marta takrorlaydi.

Eski Go da bu shakl yo'q

for i := range 5 faqat Go 1.22 va undan keyingi versiyalarda ishlaydi. Undan oldingi kodda klassik shakl yoziladi:

Go
for i := 0; i < 5; i++ {

Agar go.mod faylingizda go 1.21 yozilgan bo'lsa, yangi shakl ishlamaydi - Go modulning versiyasiga qarab qaror qiladi.

range bilan yurish #

Go
package main

import "fmt"

func main() {
    shaharlar := []string{"Namangan", "Andijon", "Buxoro"}

    for i, shahar := range shaharlar {
        fmt.Printf("%d: %s\n", i, shahar)
    }

    fmt.Println("---")

    for _, shahar := range shaharlar {
        fmt.Println(shahar)
    }
}
Natija
0: Namangan
1: Andijon
2: Buxoro
---
Namangan
Andijon
Buxoro

range ikkita qiymat beradi: indeks va elementning o'zi.

Indeks kerak bo'lmasa, uning o'rniga _ yoziladi. Bu "bu qiymat menga kerak emas" degani.

Ishlatilmagan o'zgaruvchi - xato

Agar for i, shahar := range ... deb yozib, i ni ishlatmasangiz, dastur kompilyatsiya bo'lmaydi:

KOD
i declared and not used

Aynan shuning uchun _ belgisi kerak. U maxsus nom: unga qiymat berish mumkin, lekin uni o'qib bo'lmaydi va u hech qanday xotira egallamaydi.

Nima bo'yichaBirinchi qiymatIkkinchi qiymat
slice / massivIndeksElement
stringBayt o'rniRuna
mapKalitQiymat
KanalElement-
Butun son0 dan boshlab hisob-

Faqat indeks kerak bo'lsa #

Go
package main

import "fmt"

func main() {
    ballar := []int{85, 92, 78}

    for i := range ballar {
        ballar[i] += 5
    }
    fmt.Println(ballar)
}
Natija
[90 97 83]

Ikkinchi qiymatni butunlay tashlab ketish mumkin. Bu yerda bu muhim: elementni o'zgartirish kerak, shuning uchun indeks bo'yicha murojaat qilinmoqda.

range nusxa beradi

Bu kod hech narsani o'zgartirmaydi:

Go
for _, ball := range ballar {
    ball += 5
}

ball - elementning nusxasi. Uni o'zgartirish asl slicega ta'sir qilmaydi.

O'zgartirish kerak bo'lsa, yuqoridagi kabi ballar[i] orqali murojaat qiling.

break va continue #

Go
package main

import "fmt"

func main() {
    sonlar := []int{4, 8, 15, 16, 23, 42}

    for _, son := range sonlar {
        if son > 15 {
            fmt.Println("Birinchi katta son:", son)
            break
        }
        fmt.Println("Tekshirildi:", son)
    }

    fmt.Println("---")

    toqlar := []int{}
    for i := 1; i <= 10; i++ {
        if i%2 == 0 {
            continue
        }
        toqlar = append(toqlar, i)
    }
    fmt.Println(toqlar)
}
Natija
Tekshirildi: 4
Tekshirildi: 8
Tekshirildi: 15
Birinchi katta son: 16
---
[1 3 5 7 9]

break siklni to'xtatadi, continue esa faqat joriy aylanishni tashlab, keyingisiga o'tadi.

Yorliqlar #

Go
package main

import "fmt"

func main() {
    topildi := false

tashqi:
    for i := 1; i <= 4; i++ {
        for j := 1; j <= 4; j++ {
            if i*j == 6 {
                fmt.Printf("Topildi: %d * %d\n", i, j)
                topildi = true
                break tashqi
            }
        }
    }

    fmt.Println("Qidiruv tugadi:", topildi)
}
Natija
Topildi: 2 * 3
Qidiruv tugadi: true

Oddiy break faqat ichki siklni to'xtatadi. Ikkalasidan ham chiqish uchun yorliq qo'yiladi.

continue ham yorliq bilan ishlaydi: continue tashqi tashqi siklning keyingi aylanishiga o'tadi.

Yorliqni kam ishlating

Yorliq ba'zan kerak, lekin u kodni o'qishni qiyinlashtiradi.

Ko'p hollarda ichki siklni alohida funksiyaga chiqarib, undan return qilish tozaroq yechim bo'ladi. Shunda yorliq ham, qo'shimcha bayroq o'zgaruvchisi ham kerak emas.

Funksiyalarni keyingi bo'limda o'rganamiz.

Ichma-ich sikllar #

Go
package main

import (
    "fmt"
    "strings"
)

func main() {
    for i := 1; i <= 3; i++ {
        qatorlar := []string{}
        for j := 1; j <= 3; j++ {
            qatorlar = append(qatorlar, fmt.Sprintf("%2d", i*j))
        }
        fmt.Println(strings.Join(qatorlar, " "))
    }
}
Natija
 1  2  3
 2  4  6
 3  6  9

%2d - sonni kamida ikki belgi joyga, o'ngga tekislab chiqaradi. Shuning uchun ustunlar to'g'ri turadi.

Sikl - ifoda emas #

for qiymat qaytarmaydi

Ba'zi tillarda sikldan qiymat olish mumkin. Go da esa for - faqat buyruq, ifoda emas:

Go
natija := for i := range 5 { }   // xato

Natija yig'ish kerak bo'lsa, siklidan tashqarida o'zgaruvchi e'lon qilib, ichida to'ldirasiz - yuqoridagi kvadratlar va toqlar misollaridagi kabi.

Go da map yoki filter kabi tayyor funksiyalar ham yo'q. Bu ataylab: jamoa tilni kichik saqlashni afzal ko'rgan. Generiklar qo'shilgandan keyin (17-bo'lim) ularni o'zingiz yozishingiz mumkin.

Amaliy misol #

Go
package main

import "fmt"

func main() {
    ballar := []int{85, 92, 78, 95, 88}

    jami := 0
    engYuqori := ballar[0]

    for _, ball := range ballar {
        jami += ball
        if ball > engYuqori {
            engYuqori = ball
        }
    }

    ortacha := float64(jami) / float64(len(ballar))

    fmt.Println("Jami:", jami)
    fmt.Printf("O'rtacha: %.1f\n", ortacha)
    fmt.Println("Eng yuqori:", engYuqori)
}
Natija
Jami: 438
O'rtacha: 87.6
Eng yuqori: 95

E'tibor bering: float64(jami) / float64(len(ballar)) - ikkala tomon ham aniq o'tkazilgan. Aks holda natija butun son bo'lib, 87.6 o'rniga 87 chiqardi.

Amaliy topshiriq
  1. Klassik for bilan 1 dan 10 gacha yig'indini hisoblang.
  2. Xuddi shuni while shaklida yozing.
  3. for { } va break bilan cheksiz sikldan chiqing.
  4. for i := range 5 shaklini sinab ko'ring.
  5. range bilan ro'yxatni indeksi bilan chiqaring.
  6. _ ishlatib, indeksni tashlab keting.
  7. range nusxa berishini isbotlang.
  8. continue bilan faqat toq sonlarni yig'ing.
  9. Yorliq bilan ichma-ich sikldan butunlay chiqing.
  10. Ko'paytirish jadvalini tekislangan ustunlarda chiqaring.

Xulosa #

  • Go da bitta sikl kalit so'zi bor - for; while va foreach yo'q.
  • To'rt shakl: klassik, while shakli, cheksiz for { } va range.
  • for i := range 5 - Go 1.22 dan boshlab ishlaydi.
  • range ikki qiymat beradi; keraksizini _ bilan tashlang - ishlatilmagan o'zgaruvchi xato.
  • range elementning nusxasini beradi; o'zgartirish uchun royxat[i] orqali murojaat qiling.
  • break va continue yorliq bilan ishlaydi, lekin ko'pincha alohida funksiya tozaroq yechim.
  • for - buyruq, ifoda emas: natijani tashqaridagi o'zgaruvchiga yig'asiz.

Keyingi bo'limda funksiyalarni 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.