Kod mantig'i: shart, sikl va funksiya

O'zgaruvchi, shart, sikl va funksiyadan tuzilgan dastur mantigi sxemasi — Kod tili o’zgarsa ham, dastur mantiqining asosiy qismlari bir xil qoladi.

Algoritm masalani aniq qadamlarga bo’ladi. Endi shu qadamlarni deyarli barcha dasturlash tillarida uchraydigan to’rtta vosita bilan ifodalaymiz. Bu muayyan til sintaksisi emas: maqsad kod ko’rinishidagi fikrni tushunish.

To’rtta tayanch

O’zgaruvchi

O’zgaruvchi qiymatni saqlash uchun berilgan nom. Masalan, hisob-kitobdagi umumiy narxni jami deb atalgan joyga yozib borish mumkin.

jami = 0
jami = jami + 12000
jami = jami + 8000

Bu yerda = matematik tenglik emas, o’ng tomondagi natijani chapdagi nomga saqlash buyrug’i.

Shart va sikl

Shart dasturga vaziyatga qarab qaror qilish imkonini beradi. Sikl esa bir xil amalni qaytaradi. Masalan, har bir bahoni jamiga qo’shish uchun ro’yxat bo’ylab yuriladi. Sikl qachon to’xtashi aniq bo’lishi shart.

Funksiya

Funksiya — bir vazifani bajaradigan, nom berilgan qadamlar guruhi. U takrorni kamaytiradi: katta masalani funksiyalar orqali kichik, o’qiladigan qismlarga ajratasiz.

Kichik mashq

Uchta sonning eng kattasini topish uchun psevdokod yozing. Avval o’zgaruvchilar va shartlarni aniqlang, keyin uni Python yoki JavaScript sintaksisiga o’tkazing.

Amalda qo’llash

Bir masalani to’rt qismga ajratish

Masalan, kutubxonadagi kitobni vaqtida qaytarish uchun jarima hisoblaydigan dastur kerak, deylik. Bu vazifada avval ma’lumotlarni aniqlaymiz: kechikkan_kun, kunlik_jarima va jami_jarima. Ularning har biri o’zgaruvchi bo’ladi. Keyin qoida keladi: kechikish bo’lmasa jarima ham bo’lmaydi; bo’lsa, kunlar soni bilan stavkani ko’paytiramiz. Ko’p foydalanuvchi bo’lsa, har birini sikl orqali ko’ramiz. Hisoblash qoidasi esa jarima_hisobla funksiyasiga joylashadi.

funksiya jarima_hisobla(kechikkan_kun, kunlik_jarima):
    agar kechikkan_kun <= 0 bo'lsa:
        0 ni qaytar
    aks holda:
        kechikkan_kun * kunlik_jarima ni qaytar

Psevdokodning qiymati shundaki, bu yerda Python’dagi ikki nuqta, JavaScript’dagi qavs yoki boshqa belgi haqida o’ylamaysiz. Avval qoida to’g’rimi, kirish va chiqish ma’lumoti yetarlimi, shuni tekshirasiz. Sintaksis keyingi qadam.

Dry run: qiymatlarni qo’lda kuzatish

Kompyuter ichida nima sodir bo’lishini tasavvur qilish uchun jadvaldan foydalaning. Yuqoridagi funksiya kechikkan_kun = 3, kunlik_jarima = 2000 bilan chaqirilsa, qadamlar quyidagicha:

Qadam	Savol yoki amal	Natija
1	`3 <= 0` rostmi?	Yo’q
2	Aks holdagi yo’l tanlanadi	—
3	`3 * 2000` hisoblanadi	6 000
4	Funksiya qiymatni qaytaradi	6 000

Jarima algoritmida shart, hisoblash va natijani qadam-baqadam tekshirish jadvali — Dry run qiymatlarning qaysi qadamda o’zgarishini ko’rib, mantiqiy xatoni kod ishlashidan oldin topishga yordam beradi.

Endi kechikkan_kun = 0 bilan qayta sinang. Birinchi shart rost bo’ladi va dastur 0 qaytaradi. Aynan shu kabi chekka holatlarni qo’lda tekshirish keyinchalik test yozishga tayyorlaydi.

Qaysi vosita qachon kerak?

Ko’p boshlovchi shart, sikl va funksiyani bir-birining o’rniga ishlatishga urinadi. Quyidagi savol tanlashni osonlashtiradi:

Qiymatni keyinroq ishlatish kerakmi? — o’zgaruvchi.
Javobga qarab ikki yoki undan ortiq yo’ldan biri tanlanadimi? — shart.
Bir qoida bir nechta elementga tatbiq qilinadimi? — sikl.
Bir xil qadamlar boshqa joylarda ham kerak bo’ladimi? — funksiya.

Bir funksiya juda ko’p ish qilsa, uni kichraytirish kerak bo’lishi mumkin. Masalan, xarajatlar ilovasida “kiritishni tekshir”, “jami hisobla” va “natijani ko’rsat” uchta alohida vazifa; ularni bitta ulkan funksiya o’rniga uchta nomlangan qismga bo’lish o’qishni va debuggingni yengillashtiradi.

Psevdokoddan haqiqiy kodga o’tish

Til tanlaganingizda birinchi navbatda o’zgaruvchi qanday yaratilishini, shart qanday yozilishini, siklning qaysi turi borligini va funksiya qanday qiymat qaytarishini bilasiz. Ammo atamalar o’zgarsa ham savollar o’zgarmaydi: qiymat qayerdan keladi, qaysi qoida uni o’zgartiradi, natija qayerga ketadi? Shuning uchun bu dars Python va kelajakdagi JavaScript darslariga ko’chadigan poydevordir.

Mantiqni ko’rinarli qilish

Ma’lumot oqimini chizish

Kod mantig’ini tushunish uchun qiymat qayerdan kelib, qayerga ketayotganini chizing. Masalan, xarajat summasi inputdan keladi, validatsiyadan o’tadi, ro’yxatga qo’shiladi, sikl jami hisoblaydi, shart budjetdan oshganini tekshiradi va funksiya natijani qaytaradi. Bir qiymat qaysi qadamda o’zgargani aniq bo’lsa, debugging osonlashadi.

Qiymat turini ham oldindan belgilang. "12000" matni bilan 12000 soni tashqi ko’rinishda o’xshash, ammo hisoblashda turlicha ishlaydi. Foydalanuvchi kiritgan ma’lumot odatda matn sifatida keladi, dastur esa kerak bo’lsa uni songa aylantiradi va yaroqliligini tekshiradi.

Funksiya chegarasi

Funksiya bitta tushunarli vazifaga ega bo’lsin. jami_hisobla xarajatlarni olib son qaytarsin; u ekranga xabar chiqarish yoki faylga saqlash bilan bir vaqtda shug’ullanmasin. Bunday ajratish funksiyani alohida sinashga va boshqa joyda qayta ishlatishga yordam beradi.

Sikldagi keng tarqalgan xatolar

Sikl boshlang’ich qiymatini har aylanishda qayta nolga tushirib qo’ymang; aks holda jami faqat oxirgi elementga teng bo’lib qoladi. Ro’yxatni aylanish paytida tartibsiz o’zgartirish ham element o’tkazib yuborilishiga olib kelishi mumkin. Sikl tugash sharti aniq bo’lmasa, cheksiz aylanish yuz beradi. Har sikl uchun “nima o’zgaradi?” va “qachon to’xtaydi?” savoliga javob yozing.

Shartlarning tartibi

Shartlar yuqoridan pastga tekshiriladi. Umumiy shartni juda oldin yozsangiz, keyingi maxsus holatga hech qachon navbat kelmasligi mumkin. Har ikki yo’lning ham natijasini yozib, kamida bittadan misol bilan sinang.

Mini testlar

Kirish	Kutilgan natija
`[12000, 8000]`, budjet 30 000	Budjet ichida
`[25000, 10000]`, budjet 30 000	Budjetdan oshdi
`[]`, budjet 30 000	Jami 0, aniq bo’sh holat
`[-5000]`	Validatsiya xatosi

Test jadvali funksiyaning nomi to’g’ri bo’lsa ham, qoidasi to’g’ri ishlashini tekshiradi. Keyin shu misollarni Python yoki JavaScriptda yozib, qo’lda dry run bilan solishtiring.

Kirish, ishlov va chiqishni ajrating

Har bir kichik dasturda uchta qatlamni ko’rishga odatlaning: kirish, ishlov va chiqish. Kirish foydalanuvchi yozgan qiymat, fayldan o’qilgan satr yoki boshqa funksiyadan kelgan natija bo’lishi mumkin. Ishlov qismida ma’lumot tekshiriladi, shartlar tanlanadi va kerakli hisob amalga oshadi. Chiqish esa ekranga xabar, qaytarilgan qiymat yoki saqlangan ma’lumotdir. Bu ajratish kodning qayerida muammo borligini tezroq topishga yordam beradi.

Masalan, xarajat qo’shish vazifasida summa kirish bo’ladi. Dastur avval u son ekanini va manfiy emasligini tekshiradi. So’ngra uni ro’yxatga qo’shadi, jami xarajatni hisoblaydi va budjet holatini aniqlaydi. Oxirida foydalanuvchiga yangi jami ko’rsatiladi. Agar natija noto’g’ri chiqsa, darhol hamma kodni o’zgartirmang: qiymat noto’g’ri keldimi, hisob xatomi yoki faqat chiqarish noto’g’rimi, shu uch nuqtani alohida tekshiring.

funksiya xarajat_qosh(summa, xarajatlar, budjet):
    agar summa son bo'lmasa yoki summa <= 0 bo'lsa:
        "Summa noto'g'ri" ni qaytar

    xarajatlar ga summa ni qo'sh
    jami = jami_hisobla(xarajatlar)

    agar jami > budjet bo'lsa:
        "Budjetdan oshdi: " + jami ni qaytar
    aks holda:
        "Jami xarajat: " + jami ni qaytar

Bu misolda funksiya ichidagi vazifalar ko’rinib turadi, biroq loyiha kattalashganda tekshirish, ro’yxatga qo’shish va xabar tuzishni yana maydaroq funksiyalarga ajratish mumkin. Ajratishning maqsadi qatorlar sonini majburan kamaytirish emas; maqsad har qismning javobgarligini tushunarli qilishdir.

Chekka holatlar bilan fikrlash

Algoritm odatiy misolda ishlashi hali u ishonchli degani emas. Har bir qoida uchun nol, bo’sh, eng katta, takroriy va noto’g’ri kirishlarni tasavvur qiling. Kontakt qidirishda bo’sh ro’yxat; baho hisoblashda bitta baho; jarimada manfiy kun; parol tekshirishda bo’sh satr chekka holatlarga misol bo’ladi. Bunday holatlarni oldindan yozish shartlarni aniqroq qiladi.

Chekka holat uchun dastur nima qilishi kerakligini so’z bilan belgilab oling. Masalan, xarajatlar ro’yxati bo’sh bo’lsa jami 0 qaytarilishi mumkin. Ammo foydalanuvchi "o'n ming" deb yozsa, dastur uni jim turib nol deb qabul qilmasin: tushunarli xato xabari qaytarsin. Qoidaning bunday ochiq tavsifi keyin test yozayotganda ham, boshqa dasturchi kodni o’qiyotganda ham noaniqlikni kamaytiradi.

Nomlash mantiqni ko’rinarli qiladi

Yaxshi nom kodning qo’shimcha izohisiz ma’noni yetkazadi. x, a1 yoki natija2 kichik tajribada yetarli ko’rinishi mumkin, lekin real masalada jami_xarajat, qolgan_budjet, topilgan_kontakt kabi nomlar xatoni kamaytiradi. Mantiqni o’qiyotgan odam qiymat nimani anglatishini taxmin qilmaydi. Bir tilda va bir uslubda nomlash ham muhim: masalan, hamma nomni o’zbekcha pastki chiziq bilan yoki loyiha qoidasi talab qilgan boshqa usulda yozing.

Funksiya nomi ham bajaradigan ishni fe’l bilan aytsin: jarima_hisobla, kontakt_top, baho_tekshir. ishla yoki malumot kabi umumiy nomlar keyinchalik qaysi qadam qayerda ekanini yashiradi. Nom uzoq bo’lib ketishidan qo’rqmang, faqat u aniq va keraksiz takrorsiz bo’lsin.

Bir daqiqalik tekshiruv ro’yxati

Kod yozishdan avval va keyin quyidagini so’rang: kirish qiymati aniqmi, barcha shart yo’llari qamrab olinganmi, sikl to’xtaydimi, funksiya bitta vazifani bajaryaptimi va natija tekshirildimi? Shu qisqa ro’yxat oddiy mantiqiy xatolarning katta qismini ushlaydi.

Xulosa

O’zgaruvchi qiymat saqlaydi, shart yo’lni tanlaydi, sikl takrorlaydi, funksiya esa qadamlarni nomlab qayta ishlatadi.

Keyingi darsda debugging asoslari — xato bo’lganda ularni izchil tekshirish va sababni topishni o’rganamiz.