Go (yoki Golang) — Google yaratgan zamonaviy dasturlash tili. U sodda sintaksis, tez kompilyatsiya, yuqori unumdorlik va oson parallellikni birlashtiradi. Shu sababli Go bugungi kunda backend, mikroxizmatlar, CLI dasturlar va DevOps vositalarini yaratishda eng ommabop tillardan biri hisoblanadi.

2007-yilda Google muhandislari katta muammoga duch kelishdi. Kompaniyaning dasturlari tobora yiriklashib, millionlab foydalanuvchilarga xizmat ko'rsata boshladi. Ammo mavjud dasturlash tillari bunday miqyosdagi tizimlarni yaratishda turli qiyinchiliklarni keltirib chiqarardi.

Bir tomondan, C++ juda tez ishlardi, ammo kod yozish va kompilyatsiya qilish murakkab hamda sekin edi. Ikkinchi tomondan, Python sodda va qulay bo'lsa-da, katta yuklama ostida unumdorligi yetarli emas edi.

Shu sababli Google muhandislari ikkala tilning eng yaxshi jihatlarini birlashtiradigan yangi dasturlash tilini yaratishga qaror qilishdi. Natijada Go dasturlash tili dunyoga keldi.

Google'ning ko'p xizmatlari C++ dasturlash tilida yozilgan edi. Bu til juda tez ishlaydi va katta tizimlar yaratish uchun kuchli imkoniyatlarga ega. Ammo loyihalar yiriklashgani sari C++ bilan ishlash tobora qiyinlashib bordi.

Shu sababli Google dasturchilari tez ishlaydigan, ammo undan foydalanish osonroq bo'lgan tilni xohlashardi.

Python esa C++ ning aksincha, juda sodda va tushunarli til edi. Unda dastur yozish tez, kodni o'qish esa oson. Shu sababli u ko'plab dasturchilar orasida mashhur edi.

Ammo Google kabi ulkan tizimlar uchun Python'ning ham ayrim cheklovlari bor edi.

Google'ga esa ham sodda, ham yuqori unumdorlikka ega til kerak edi.

Google muhandislari yangi til yaratishda bitta maqsadni ko'zladilar: C++ ning tezligini Python'ning soddaligi bilan birlashtirish.
Shuning uchun Go quyidagi xususiyatlar bilan yaratildi:

Natijada 2007-yilda Go ustida ish boshlandi va 2009-yilda u ochiq manba (Open Source) sifatida e'lon qilindi. Bugungi kunda Go bulut texnologiyalari, mikroxizmatlar, DevOps vositalari va yuqori yuklamali server dasturlarini yaratishda keng qo'llaniladigan tillardan biridir.

Ularning tajribasi Go'ga ulkan asos bo'ldi. Ken Thompson Unix va C tilining ildizlarini yaratgan bo'lsa, Rob Pike UTF-8 — bugungi barcha matnlar saqlanadigan standart — muallifi. Robert Griesemer esa zamonaviy virtual mashina texnologiyasini chuqur bilardi.

Go faqat Google uchun yaratilgan bo'lsa-da, bugungi kunda butun dunyodagi eng muhim texnologiyalar uning asosida qurilgan. Docker va Kubernetes — bugungi cloud infratuzilmasining asosi — Go'da yozilgan.

misollar:

Yangi dasturlash tilini o‘rganmoqchi bo‘lgan har bir dasturchi ko‘pincha bitta savolga duch keladi: “Nega aynan shu til?”
Bu savol ayniqsa  Go uchun muhim — chunki Go nisbatan yangi til va ko'pchilik u haqida Python, Java yoki C/C++ ga nisbatan kamroq biladi.

Ammo bu taqqoslash “qaysi til yaxshiroq?” degan bahs uchun emas. Asl maqsad — har bir tilning o‘z kuchli tomonlari va qo‘llanish sohalari borligini tushunishdir. To‘g‘ri vazifa uchun to‘g‘ri vositani tanlagan dasturchi har doim samaraliroq ishlaydi.

Go yaratuvchilari ham uni “eng yaxshi til” sifatida emas, balki aniq muammo uchun yaratishgan: katta miqyosli va parallel ishlaydigan tizimlarni sodda, tez va ishonchli yozish. Shu nuqtai nazardan qaraganda, Go’ni boshqa tillar bilan solishtirish uning nima uchun yaratilganini yaxshiroq tushunishga yordam beradi.

Quyida Go dasturlash tilini uning asosiy raqiblari — C/C++, Java va Python bilan to‘rt asosiy mezon bo‘yicha solishtiramiz. Bu mezonlar tilning real dunyodagi qo‘llanishini tushunish uchun muhim hisoblanadi.

Har bir tilni baholashda quyidagi jihatlarga e’tibor qaratiladi:

Har bir mezon bo‘yicha Go tilining qanday pozitsiyada ekanini keyingi bo‘limlarda batafsil ko‘rib chiqamiz. Taqqoslash yakunida esa eng muhim savol — “Qaysi dasturlash tilini qachon tanlash kerak?” — ga asosli va aniq javob beriladi.

Go ning eng yaqin "qarindoshi" — bu C tilidir. Aslida Go ning sintaksisi, tuzilishi va falsafasi ko'p jihatdan C dan ilhom olgan. Go'ning yaratuvchisi Ken Thompson ayni paytda C tilining ham yaratuvchisi ekanligi bejiz emas. Demak, Go — C ning merosxo'ri, lekin uning kamchiliklarini bartaraf etgan yangi avlod.

Go ning eng yaqin "qarindoshi" — C tili. Go sintaksisi, dastur tuzilishi va dizayn falsafasining ko‘plab jihatlari C tilidan ilhom olgan. Bu bejiz emas: Go yaratuvchilaridan biri Ken Thompson Unix tizimini yaratgan muhandislardan biri bo‘lib, C tili shakllangan muhitda ishlagan. Shuningdek, Go yaratuvchisi Rob Pike ham Unix falsafasining davomchisi hisoblanadi.

C kompyuter resurslari ustidan deyarli to'liq nazorat beradi. Dasturchi xotira, protsessor va boshqa tizim resurslari bilan bevosita ishlaydi. Natijada juda tez va samarali dasturlar yaratish mumkin.

Shu sababli Linux yadrosi, Windows yadrosi, qurilma drayverlari, o'yin dvigatellari va ko'plab mikrokontroller dasturlari aynan C tilida yozilgan.

C da xotirani ajratish (malloc) va bo'shatish (free) dasturchining o'zi zimmasida bo'ladi.

Agar ajratilgan xotira vaqtida bo'shatilmasa — memory leak yuz beradi. Agar xotira noto'g'ri boshqarilsa — segmentation fault kabi xatolar sabab dastur kutilmaganda to'xtab qolishi mumkin.

Kichik dasturlarda bu muammo unchalik sezilmaydi. Ammo loyiha kattalashgani sari xotira bilan ishlash eng murakkab vazifalardan biriga aylanadi.

C juda sodda va minimalistik til. Unda generics, o'rnatilgan xatolarni boshqarish mexanizmi, map, list kabi tayyor ma'lumotlar tuzilmalari mavjud emas.

Natijada ko'plab imkoniyatlarni dasturchining o'zi yozishi yoki tashqi kutubxonalardan foydalanishi kerak bo'ladi. Bu esa dastur yozishni ham, uni keyinchalik qo'llab-quvvatlashni ham murakkablashtiradi.

C++ C tilining imkoniyatlarini yanada kengaytirdi. Unga ob'ektga yo'naltirilgan dasturlash (OOP), template, STL (Standard Template Library) va boshqa ko'plab zamonaviy imkoniyatlar qo'shildi.
Natijada C++ yuqori unumdorlikni saqlab qolgan holda murakkab dasturlarni yaratishga imkon berdi. Bugungi kunda Unreal Engine, Google Chrome, ko'plab grafik dasturlar, ma'lumotlar bazalari va yuqori unumdor serverlar C++ yordamida ishlab chiqilgan.

C++ ning imkoniyatlari kengaygani sari kompilyatsiya jarayoni ham murakkablashdi. Ayniqsa, millionlab qator koddan iborat yirik loyihalarda bu katta muammoga aylandi.

Masalan, Google ichidagi ayrim C++ loyihalarini to'liq kompilyatsiya qilish 30 daqiqadan 1 soatgacha vaqt olardi. Dasturchi bitta qator kodni o'zgartirgach, natijani ko'rish uchun uzoq kutishga majbur bo'lardi. Bu esa ishlab chiqish jarayonini sezilarli darajada sekinlashtirardi.

C++ juda kuchli til, ammo shu bilan birga juda murakkab ham.

Ko'pincha bitta muammoni hal qilishning bir nechta usuli mavjud. OOP, template, ko'p turdagi meros olish (inheritance), pointerlar, manual xotira boshqaruvi va undefined behavior kabi tushunchalar tilni o'rganish va undan xavfsiz foydalanishni ancha qiyinlashtiradi.

Natijada, hatto tajribali dasturchilar ham ba'zan kutilmagan xatolarga duch kelishadi.

Ko'p yadroli protsessorlar ommalashgach, bir vaqtning o'zida bir nechta vazifani bajarish muhim ahamiyat kasb eta boshladi.

C++ da buning uchun odatda thread, mutex, condition_variable kabi vositalardan foydalaniladi. Biroq ularni noto'g'ri ishlatish juda oson.

Natijada race condition, deadlock, data race kabi aniqlash qiyin bo'lgan xatolar yuzaga kelishi mumkin. Ayniqsa, katta jamoalarda yozilgan yirik loyihalarda bunday xatolarni topish va tuzatish ko'p vaqt talab qiladi.

Shunday bo'lsa-da, C va C++ bugungi kungacha eng muhim va eng kuchli tizimli dasturlash tillari qatorida turadi. Ular tezlik, unumdorlik va apparat ustidan yuqori darajadagi nazorat talab qilinadigan ko'plab sohalarda hanuzgacha asosiy tanlov hisoblanadi.

Biroq 2000-yillarga kelib dasturiy ta'minot hajmi keskin oshdi. Millionlab qator kod, katta dasturchilar jamoalari, ko'p yadroli protsessorlar va bulutli infratuzilmalar yangi muammolarni yuzaga chiqardi. C va C++ bu vazifalarni bajarishga qodir edi, ammo ularning murakkabligi, sekin kompilyatsiyasi va parallellik bilan ishlashdagi qiyinchiliklari ishlab chiqish jarayonini sekinlashtirardi.

Shu sababli Google muhandislari C va C++ ning yuqori unumdorligini saqlab qolgan, biroq soddaroq, tez kompilyatsiya qilinadigan va zamonaviy server dasturlashiga mos yangi til yaratishga kirishdilar. Natijada Go dasturlash tili dunyoga keldi.

Ammo Go C/C++ ni to'liq almashtira olmaydi. Operatsion tizim yadrosi, qurilma drayverlar, o'yin dvigatellari kabi to'g'ridan-to'g'ri apparat bilan ishlash kerak bo'lgan sohalarda C/C++ hamon ustun. Go esa bu darajadagi past darajali nazoratni taqdim etmaydi.

Java — Go ga eng yaqin raqib tillardan biri. Ikkalasi ham statik tiplashga ega, ikkalasi ham korporativ darajadagi tizimlar uchun keng qo'llaniladi va ikkalasida ham avtomatik axlat yig'uvchi (garbage collector) mavjud. Shunga qaramay, ular orasidagi farqlar juda muhim.

Java kodi JVM (Java Virtual Machine) ustida ishlaydi. Shu sababli bitta Java dasturini Windows, macOS yoki Linux tizimlarida hech qanday o'zgartirishsiz ishga tushirish mumkin.
Bu yondashuv korporativ muhitda katta afzallik beradi, chunki platformaga bog'liqlikni kamaytiradi.

Java 30 yildan ortiq tarixga ega bo'lgan til. Uning atrofida juda katta ekotizim shakllangan: Spring, Hibernate, Maven, Gradle kabi yuzlab professional framework va kutubxonalar mavjud.
Bugungi kunda bank tizimlari, korporativ dasturlar va hatto Android ilovalarining katta qismi Java ekotizimiga tayanadi.

Java dasturini ishga tushirish uchun avval JVM yuklanadi. Bu jarayon Go kabi kompilyatsiya qilingan tillarga nisbatan ko'proq vaqt talab qiladi.
Ayniqsa mikroservislar va serverless muhitlarda bu sezilarli muammo bo'lishi mumkin, chunki tez-tez ishga tushib-to'xtaydigan servislar uchun “startup time” muhim ahamiyatga ega.

JVM o'zi ham ma'lum miqdorda xotira talab qiladi. Shu sababli Java ilovalari odatda Go dasturlariga nisbatan ko'proq RAM ishlatadi.
Bu farq ayniqsa konteyner (Docker, Kubernetes) muhitlarida sezilarli bo'ladi, chunki resurslar qat'iy chegaralangan bo'ladi.

Java'da oddiy dastur yozish uchun ham ko'proq “boilerplate” kod talab qilinadi. Masalan, oddiy “Salom, dunyo” dasturi ham class va public static void main kabi majburiy tuzilmani o'z ichiga oladi.

Go esa shu kabi vazifalarni ancha ixcham sintaksis bilan ifodalaydi. 

Java'da parallel dasturlash uchun Thread, ExecutorService, synchronized kabi bir nechta past darajadagi mexanizmlarni chuqur tushunish talab etiladi.
Noto'g'ri ishlatilganda esa deadlock yoki boshqa sinxronizatsiya muammolari yuzaga kelishi mumkin.

Go esa bu jarayonni ancha soddalashtiradi va ko'p hollarda engil “goroutine” modeli bilan ishlash imkonini beradi.

Eng oddiy misol — "Salom dunyo" dasturi. Ikki tilda qancha kod yozish kerakligini ko'rib chiqamiz:

Ammo Java ham hali Go to'liq almashtira olmagan sohalar mavjud.

Masalan, Android ilovalar ekotizimi uzoq yillar davomida Java (hozirda ko'proq Kotlin) atrofida shakllangan. Shuningdek, yirik korporativ tizimlar — banklar, sug'urta kompaniyalari va ERP platformalari — bugungi kunda ham asosan Java ekotizimiga tayanadi.

Buning asosiy sababi Java’ning juda katta va yetuk ekotizimga ega ekanligidir. Ayniqsa Spring Framework kabi kuchli vositalar murakkab biznes logikani tez va ishonchli qurishga imkon beradi.

Shu nuqtai nazardan qaraganda, Go ko'plab yangi tizimlar uchun ideal tanlov bo'lsa ham, Java o'zining barqarorligi va ulkan infratuzilmasi bilan korporativ dunyoda hanuzgacha kuchli o'rnini saqlab qolmoqda.

Python — bugungi kunda eng mashhur dasturlash tillaridan biri. U oddiy sintaksisi va tez o'rganilishi bilan ajralib turadi.

Bugungi kunda sun'iy intellekt, ma'lumotlar tahlili, avtomatlashtirish, skript yozish va tez prototiplash kabi sohalarning katta qismi Python ekotizimi asosida qurilgan.

Go va Python esa ko'pincha bir-biriga qarama-qarshi tillar sifatida qaraladi. Ularning falsafasi, ishlash modeli va maqsadi tubdan farq qiladi:

Python — tez yozish, qulaylik va moslashuvchanlikka urg'u beradi
Go — tez ishlash, samaradorlik va tizim darajasidagi ishonchlilikka urg'u beradi

Shu sababli bu ikki til ko'pincha bir xil muammo uchun emas, balki turli bosqichlar va turli ehtiyojlar uchun ishlatiladi.

Python sintaksisi inson tiliga juda yaqin bo'lib, eng tushunarli dasturlash tillaridan biri hisoblanadi. Shu sababli yangi boshlovchi hatto birinchi kunning o'zidayoq oddiy ishlaydigan dastur yoza oladi.

Aynan shu qulaylik sababli Python ko'pincha maktab lar, universitetlar va dasturlash kurslarida birinchi til sifatida o'rgatiladi.

Python ekotizimi sun'iy intellekt va ma'lumotlar bilan ishlashda yetakchi hisoblanadi. NumPy, Pandas, TensorFlow, PyTorch kabi kuchli kutubxonalar aynan Python atrofida shakllangan.

Shu sababli machine learning, data science va ilmiy tadqiqotlar sohasida Python hali ham eng asosiy tillardan biri bo'lib qolmoqda.

Python g'oyalarni tez sinab ko'rish uchun juda qulay. Bir necha qator kod bilan ishlaydigan prototip yaratish mumkin.

Bu esa startaplar va tadqiqotchilar uchun katta afzallik bo'lib, mahsulot g'oyasini tez tekshirish imkonini beradi. 

Python interpretatsiya qilinadigan til bo'lib, kod bajarilish vaqtida qatorma-qator talqin qilinadi. Shu sababli u kompilyatsiya qilingan tillarga, xususan Go ga nisbatan ancha sekin ishlaydi.

Katta yuklamali tizimlarda yoki millionlab so'rovlarni qayta ishlashda bu farq sezilarli bo'lishi mumkin. 

Python'da Global Interpreter Lock (GIL) mavjud. Bu mexanizm bir vaqtning o'zida faqat bitta thread Python kodini bajarishini ta'minlaydi.

Natijada, ko'p yadroli protsessorlardan to'liq foydalanish cheklanadi. Go esa goroutine modeli orqali barcha yadro resurslaridan samarali foydalanadi.

Python dinamik tiplashga ega: o'zgaruvchining turi ishga tushish vaqtida aniqlanadi. Bu yozishni osonlashtiradi, lekin katta loyihalarda yashirin xatolarga olib kelishi mumkin.

Ko'pincha bunday xatolar faqat dastur ishga tushgandan keyin aniqlanadi. Go esa bunday xatolarni kompilyatsiya vaqtidayoq ushlab qoladi.

Python dasturini serverga joylashtirish uchun interpretator, dependency'lar va virtual muhitni to'g'ri sozlash kerak bo'ladi.

Go'da esa aksincha — bitta kompilyatsiya qilingan binary fayl yetarli bo'lib, uni hech qanday qo'shimcha sozlamasiz ishga tushirish mumkin.

Ammo shuni ham unutmaslik kerakki, Python hali ham ko‘plab sohalarda Go tomonidan to‘liq almashtirilmagan va hatto raqobat ham qila olmaydigan darajada ustun.

Eng katta ustunliklardan biri — sun’iy intellekt va machine learning ekotizimi. Bugungi kunda TensorFlow, PyTorch, scikit-learn kabi eng muhim kutubxonalar aynan Python atrofida shakllangan. Bu ekotizim shunchalik katta va yetukki, u hozircha boshqa tillarga to‘liq ko‘chib o‘tmagan.

Shuningdek, ilmiy tadqiqotlar, ma’lumotlar tahlili va tezkor skriptlar yozish sohalarida Python hanuzgacha eng qulay va eng ko‘p ishlatiladigan til hisoblanadi. Uning sodda sintaksisi va boy kutubxonalar ekotizimi tadqiqotchilar va data analystlar uchun katta qulaylik yaratadi.

Shu sababli Go tizim darajasidagi dasturlar, mikroservislar va server infratuzilmasida kuchli bo‘lsa ham, Python ilmiy va AI ekotizimida hali ham yetakchi o‘rinni saqlab qolmoqda.

Oldingi qismlarda har bir tilni alohida ko'rib chiqdik. Endi ularni bir joyda — bitta jadvalda taqqoslaymiz. Bu jadval sizga qaysi til qaysi mezon bo'yicha qancha ball olishini ko'rsatadi.

Ko‘pchilik yangi dasturlash tilini o‘rganishni boshlaganda birinchi navbatda uni tezda yuklab olib o‘rnatishga shoshiladi. Bu tabiiy hol — darhol kod yozishni boshlash istagi har bir dasturchida bo‘ladi.

Lekin shu yerda bir daqiqa to‘xtab, muhim bir savolni o‘zimizga beraylik:

Go o‘rnatilganda kompyuterimizga aslida nima qo‘shiladi?

Bu savol oddiy ko‘rinsa ham, juda muhim. Chunki dasturlash tilini faqat “ishlatish” emas, balki uning qanday ishlashini tushunish — haqiqiy dasturchini shakllantiradi.

Agar biz bu savolga javobni bilmasdan turib Go’ni o‘rnatib yuborsak, bu ko‘r-ko‘rona foydalanishga o‘xshaydi. Bunday yondashuv esa keyinchalik muammo yuzaga kelganda chalkashlikka olib keladi: “Nima uchun bu ishlamayapti?”, “Qayerda xato qildim?” degan savollar paydo bo‘ladi.

Shuning uchun biz boshqacha yo‘l tutamiz: avval Go’ning ichki tuzilmasini tushunamiz, keyin esa uni kompyuterimizga o‘rnatamiz.

Go'ni rasmiy saytidan yuklab o'rnatganingizda kompyuteringizga uchta asosiy komponent o'rnatiladi:

⚙️ Go kompilyatori (Compiler)
Siz yozgan Go manba kodini (source code) kompyuter bajarishi mumkin bo‘lgan mashina kodiga (machine code) aylantiruvchi dastur. go build buyrug‘i bajarilganda aynan kompilyator bajariladigan (executable) faylni yaratadi. go run esa kodni vaqtinchalik kompilyatsiya qilib, darhol ishga tushiradi.

📦 Standart kutubxona (Standard Library)
Go bilan birga yuzdan ortiq standart paketlar o‘rnatiladi. HTTP server yaratish, JSON bilan ishlash, fayllarni o‘qish va yozish, kriptografiya, tarmoq dasturlash kabi ko‘plab vazifalarni qo‘shimcha kutubxonalar o‘rnatmasdan bajarish mumkin. Bu Go'ning eng katta afzalliklaridan biridir.

🔧 Go vositalari (Go Toolchain)
Go dasturlarini yaratish va boshqarish uchun kerak bo‘ladigan buyruqlar to‘plami. Masalan, go build, go run, go test, go fmt va go mod buyruqlari Go bilan birga avtomatik o‘rnatiladi. Ular yordamida loyihani kompilyatsiya qilish, dasturni ishga tushirish, testlarni bajarish, kodni formatlash va modullarni boshqarish amalga oshiriladi.

Quyidagi yorliqlardan (tab) kompyuteringizdagi operatsion tizimni tanlang va ko‘rsatmalarini bajaring.

Endi Go kompyuteringizga muvaffaqiyatli o‘rnatildi va ishlashga tayyor. Keyingi bobda birinchi Go dasturini yozib, uni ishga tushirishni o‘rganamiz.

Dasturlash olamida deyarli barcha dasturlash tillarini o‘rganish "Hello, World!" dasturidan boshlanadi. Bu an'ana o‘nlab yillar davomida saqlanib kelmoqda. Dastur juda oddiy bo‘lsa-da, muhim vazifani bajaradi: Go kompilyatori, terminal va kod muharriri birgalikda to‘g‘ri ishlayotganini amalda tekshirib ko‘rasiz.

Har bir Go dasturi .go kengaytmali faylda yoziladi. Shuning uchun avvalo shunday fayl yaratamiz.
Terminalni oching va quyidagi buyruqlarni ketma-ket bajaring:

Endi quyidagi buyruq orqali hello papkasini matn muharriringizda oching:

Bu buyruq joriy papkani Visual Studio Code dasturida ochadi.

hello papkasini matn muharririda ochganingizdan so'ng, chap tomondagi Explorer (fayllar ro'yxati) bo'limidan main.go faylini tanlang. Fayl ustiga bir marta bosishingiz bilan u tahrirlash oynasida ochiladi:

Endi quyidagi kodni kiriting:

Kodni yozib bo'lgach, faylni saqlang. Buning uchun Ctrl + S (Windows/Linux) yoki ⌘ + S (macOS) tugmalarini bosing.

Kodni yozib, faylni saqlaganingizdan so'ng, terminalga qayting va quyidagi buyruqni bajaring:

Agar hamma narsani to'g'ri bajargan bo'lsangiz, terminalda quyidagi natija chiqadi:

i

a

a

a

a

a

a

a

a

a

a

q

a

a

a

a

a

Dasturlarni ikki asosiy qismdan tashkil topgan deb tasavvur qilish mumkin:

Ushbu sahifa asosan shu ikki asosiy qismdan birinchisiga — ma’lumotlar(data)ga qaratiladi.

Dastur ichida ma’lumotlar turli xil usullarda saqlanishi mumkin. Ma’lumotning eng oddiy birligi esa qiymat hisoblanadi.

Qiymat — bu aniq bir ma’lumot bo‘lagi hisoblanadi. Masalan, u son yoki matn bo‘lishi mumkin. 5, 5.2 va "Hello, World!" qiymatlarga misol bo‘la oladi.

Har bir qiymat ma’lum bir toifa(type)ga tegishli bo‘ladi. Bu toifa ma’lumot turi(data type) deb ataladi. ushbu darslik davomida biz ko‘plab ma’lumot turlari bilan tanishamiz. Ulardan dastlabkilari — son(number) va satr(string) turlaridir.

4 va 3.3 kabi raqamli qiymatlar sonlar hisoblanadi. Qo‘shtirnoq ichida yozilgan belgilar ketma-ketligi, masalan "Hello, World!", satr deb ataladi. Chunki u harflar va belgilar ketma-ketligidan tashkil topadi.

Satrlar odatda qo‘shtirnoq ichida yoziladi.

Sahifa 01: Data Type nima?
• Type tushunchasi
• Static typing
• Type safety

Sahifa 02: Integer Types
• int
• int8
• int16
• int32
• int64

Sahifa 03: Unsigned Integer Types
• uint
• uint8
• uint16
• uint32
• uint64
• uintptr

Sahifa 04: Floating-Point Types
• float32
• float64

Sahifa 05: Complex Types
• complex64
• complex128

Sahifa 06: Boolean Type
• bool
• true
• false

Sahifa 07: String Type (kirish)
• string nima?
• UTF-8 matn turi
• Batafsil keyingi String bobida

Sahifa 08: byte va rune
• byte
• rune
• ASCII
• Unicode
• UTF-8

Sahifa 09: Zero Values
• Har bir type uchun zero value
• nil haqida kirish

Sahifa 10: Type Information
• %T
• reflect.TypeOf()

Sahifa 11: Numeric Limits
• Overflow
• Underflow
• math package

Sahifa 12: Best Practices
• int yoki int64?
• float32 yoki float64?
• uint qachon?
• byte va rune qachon?

Sahifa 13: Amaliy mashqlar

Sahifa 01: Value nima?
Sahifa 02: Literal nima?
Sahifa 03: Integer literals
Sahifa 04: Floating-point literals
Sahifa 05: Boolean literals
Sahifa 06: String literals
Sahifa 07: Value va Type
Sahifa 08: Common Mistakes va Best Practices
Sahifa 09: Amaliy mashqlar

O‘zgaruvchilar Go dasturlash tilidaham, boshqa dasturlash tillaridagi kabi eng asosiy tushunchalaridan biri hisoblanadi. Ular ma’lumotlarni saqlash uchun konteyner vazifasini bajaradi va kompyuter xotirasidagi ma’lum bir joy bilan bog‘lanadi.

O‘zgaruvchi ichida saqlanadigan qiymat ma'lum bir ma’lumot turiga tegishli bo‘lishi mumkin. Shuningdek, bu qiymat dastur bajarilishi davomida o‘zgarishi ham mumkin.

Aynan shu xususiyat bizga dastur ichida ma’lumotlarni saqlash, ulardan foydalanish va ular ustida turli amallar bajarish imkonini beradi.

Go dasturlash tilida o‘zgaruvchidan foydalanishdan oldin, u avval e’lon qilinishi kerak.

Oddiy qilib aytganda, o‘zgaruvchini e’lon qilish — bu kompyuter xotirasida qiymat saqlash uchun joy ajratish degani.

Go dasturlash tilida o'zgaruvchilarni e'lon qilishning bir necha xil usullari mavjud! Xar bir e'lon qilish usuli o'zgaruvchidan qanday foydalanish kerakligini ma'lum darajada ifodalab beradi!

Quyida o'zgaruvchi e'lon qilishning xar-bir usulini ko'rib chiqamiz va ularning qaysi holatda ishlatilishi maqsadga muvofiq ekanini tushunib olamiz.

Go da o‘zgaruvchilarni e’lon qilishning asosiy usullaridan biri — var kalit so‘zidan foydalanishdir. var orqali o‘zgaruvchi nomi, uning turi va kerak bo‘lsa boshlang‘ich qiymati ko‘rsatiladi.

Odatda var yordamida o‘zgaruvchi e’lon qilish funksiyaning boshida yoki funksiyadan tashqarida qo‘llanadi. Funksiyadan tashqarida o‘zgaruvchi e’lon qilish esa nisbatan kamroq uchraydi va odatda paket darajasidagi qiymatlar uchun ishlatiladi.

Go dasturlash tilida o'zgaruvchi e'lon qilishning eng to'liq usuli var key wordi orqali amalga oshiriladi. Buning uchun var kalit so‘zi, aniq tur va qiymat biriktirish ishlatiladi:

misol:

Bu yerda x — o‘zgaruvchi nomi, int — o‘zgaruvchining turi, 10 esa unga biriktirilgan boshlang‘ich qiymatdir.

Yuqoridagi usulda, agar = belgisining o‘ng tomonidagi qiymat turi o‘zgaruvchi uchun kutilayotgan turga mos bo‘lsa, bunday holatda = belgisining chap tomonidagi tur(type)ni qoldirib ketsakham bo'ladi. Go bu turni avtomatik aniqlay oladi. 

misol:

Bu kodda age nomli o‘zgaruvchi e’lon qilinadi va unga 25 qiymati beriladi. Go 25 butun son literali ekanini ko‘rib, age o‘zgaruvchisining turini avtomatik ravishda int deb belgilaydi.

Ya’ni yuqoridagi yozuv amalda quyidagi e’lon bilan bir xil ma’noni anglatadi:

Bu usul kodni biroz qisqaroq yozishga yordam beradi, lekin o‘zgaruvchining turi baribir Go tomonidan aniq belgilanadi.

Ba’zan o‘zgaruvchini e’lon qilish kerak bo‘ladi, lekin unga darhol qiymat biriktirish shart bo‘lmaydi. Bunday holatda var kalit so‘zi bilan o‘zgaruvchining turi ko‘rsatiladi, ammo = belgisi va uning o‘ng tomonidagi qiymat yozilmaydi.

masalan:

Bu yerda age nomli int turidagi o‘zgaruvchi e’lon qilindi, lekin unga aniq qiymat biriktirilmadi.

Bunday holatda Go o‘zgaruvchiga shu tur uchun oldindan belgilangan zero value qiymatini beradi. int turi uchun bu qiymat 0 hisoblanadi.

Yani, yuqoridagi e'lon age o‘zgaruvchisi int turida yaratilganini va boshlang‘ich holatda 0 qiymatga ega bo‘lishini bildiradi.

Bu usul o‘zgaruvchining turi oldindan aniq bo‘lgan, lekin uning haqiqiy qiymati keyinroq belgilanadigan holatlarda qo‘llanadi.

var yordamida bir vaqtning o‘zida bir nechta o‘zgaruvchini e’lon qilish mumkin. Bunday holatda o‘zgaruvchilar bir xil turga ega bo‘lishi yoki Go tomonidan turli turlarda aniqlanishi mumkin.

Agar o‘zgaruvchilar bir xil turga ega bo‘lsa, ularning turi oxirida bir marta yoziladi:

Bu yerda x va y nomli ikkita o‘zgaruvchi e’lon qilindi. Ularning ikkalasi ham int turiga ega. x ga 10, y ga esa 20 qiymati biriktirildi.

Agar o‘zgaruvchilarga boshlang‘ich qiymat berilmasa, ular ko‘rsatilgan turning zero value qiymatini oladi:

Bu holatda x va y o‘zgaruvchilari int turida e’lon qilinadi va ikkalasi ham boshlang‘ich holatda 0 qiymatga ega bo‘ladi.

Bir nechta o‘zgaruvchini e’lon qilishda ularning turlari har xil bo‘lishi ham mumkin. Bunday holatda Go qiymatlarga qarab har bir o‘zgaruvchining turini avtomatik aniqlaydi:

Bu yerda x o‘zgaruvchisi int, y esa string turida bo‘ladi. Chunki 10 — butun son literali, "hello" esa satr literalidir. 

var dan foydalanishning yana bir qulay ko‘rinishi — o‘zgaruvchilarni e’lonlar ro‘yxati shaklida yozishdir. Agar bir nechta o‘zgaruvchi bir joyda e’lon qilinayotgan bo‘lsa, ularni var bloki ichida tartibli joylashtirish mumkin.

misol:

Bu usul ko‘pincha bir-biriga bog‘liq yoki bir joyda e’lon qilinishi kerak bo‘lgan o‘zgaruvchilarni tartibli ko‘rsatish uchun ishlatiladi. Natijada kod o‘qilishi osonroq bo‘ladi.

Yuqoridagi misolda:

x — int turida e’lon qilingan. Unga qiymat berilmagani uchun boshlang‘ich holatda 0 qiymatiga ega bo‘ladi.
y — qiymat orqali turi aniqlangan o‘zgaruvchi. Unga 20 qiymati berilgan, shuning uchun Go uning turini int deb belgilaydi.
z — int turida e’lon qilingan va unga 30 qiymati biriktirilgan.
d va e — bir qatorda e’lon qilingan. d ga 40, e ga esa "hello" qiymati berilgan.
f va g — string turida e’lon qilingan. Ularga qiymat berilmagani uchun boshlang‘ich holatda bo‘sh satr qiymatini oladi.

Go dasturlash tilida tilida o‘zgaruvchi e’lon qilishning qisqa shakli ham mavjud. Bu usul "short variable declaration" yoki "shorthand usuli" deb ataladi va := belgisi orqali yoziladi.

Funksiya ichida bo‘lganingizda, type inference ishlatiladigan var e’loni o‘rniga := dan foydalanish mumkin.

Masalan, quyidagi ikki yozuv bir xil ma’noni anglatadi:

var x = 10

yoki qisqa shaklda:

x := 10 

Har ikkala holatda ham x nomli o‘zgaruvchi e’lon qilinadi va unga 10 qiymati beriladi. Go 10 qiymatiga qarab x o‘zgaruvchisining turini int deb aniqlaydi.

var kabi, := yordamida ham bir vaqtning o‘zida bir nechta o‘zgaruvchini e’lon qilish mumkin.

Masalan:

yoki qisqa shaklda:

Bu yerda x ga 10, y ga esa "hello" qiymati beriladi. Go qiymatlarga qarab x ning turini int, y ning turini esa string deb aniqlaydi. 

:= operatorining var bilan qilib bo‘lmaydigan qulay tomonlaridan biri shundaki, u bir vaqtning o‘zida yangi o‘zgaruvchi e’lon qilish va mavjud o‘zgaruvchiga yangi qiymat berish imkonini beradi. 

Buning uchun := belgisining chap tomonida kamida bitta yangi o‘zgaruvchi bo‘lishi kerak:

Bu misolda birinchi qatorda x nomli o‘zgaruvchi e’lon qilinadi.

Ikkinchi qatorda esa x avvaldan mavjud bo‘lgani uchun unga yangi qiymat beriladi. y esa yangi o‘zgaruvchi sifatida e’lon qilinadi.

Ya’ni bu yerda ikki xil ish bir vaqtda bajarilmoqda:

x — mavjud o‘zgaruvchi sifatida yangilanadi.

y — yangi o‘zgaruvchi sifatida e’lon qilinadi. 

:= operatorining muhim cheklovi bor: u faqat funksiya ichida ishlatiladi.

Agar o‘zgaruvchi package darajasida, ya’ni funksiyadan tashqarida e’lon qilinayotgan bo‘lsa, var ishlatilishi kerak. 

To‘g‘ri yozuv:

Noto'g'ri yozuv:

Dasturlashda ba’zi qiymatlar dastur davomida o‘zgarmas bo‘lishi kerak. Masalan, hafta kunlari soni, matematik qiymatlar, maxsus kalit nomlari yoki dastur ichida doimiy ishlatiladigan matnlar.

Bunday qiymatlar constant deb ataladi.

Go dasturlash tilida constant e’lon qilish uchun const kalit so‘zi ishlatiladi.

Constant — bu qiymati e’lon qilingandan keyin o‘zgarmaydigan doimiy qiymatdir.

Masalan: 

const appName = "CGO Docs"
const maxRetry = 3
const isActive = true

Bu yerda appName, maxRetry va isActive constant sifatida e’lon qilindi va ularning qiymatlari dastur davomida o‘zgarmaydi.

Go’da constant quyidagi ko‘rinishda e’lon qilinadi:

Bu yerda:

pi — 3.14 qiymatiga ega constant;
appName — "CGO Docs" qiymatiga ega constant;
isActive — true qiymatiga ega constant.

Constant e’lon qilingandan keyin unga qayta qiymat berib bo‘lmaydi.

masalan:

Bu kod kompilyatsiyadan o‘tmaydi. Chunki x constant sifatida e’lon qilingan.

Va kompilyator quyidagiga o‘xshash xato beradi:

Bu xato shuni bildiradi: x o‘zgarmas qiymat, unga yangi qiymat biriktirish mumkin emas.

Constant’ni aniq tur bilan ham e’lon qilish mumkin.

Bu yerda:

age — int turidagi constant;
name — string turidagi constant;
active — bool turidagi constant.

Bunday yozuv constant turi aniq ko‘rinib turishi kerak bo‘lgan holatlarda foydali.

Go’da constant’ni tur ko‘rsatmasdan e’lon qilish mumkin.

Bu holatda Go qiymatga qarab constant haqida kerakli ma’lumotni o‘zi aniqlaydi.

Masalan:

20 — son qiymat;
"Ali" — string qiymat;
true — boolean qiymat.

Kop hollarda Constantalar funksiyadan tashqarida, ya’ni package darajasida e’lon qilinadi.

misol:

Bunday constant’dan shu package ichidagi funksiyalar foydalanishi mumkin.

Masalan:

Bu qiymatlar package ichida turli joylarda kerak bo‘lishi mumkin. Shuning uchun ularni package darajasida e’lon qilish mantiqan to‘g‘ri bo'ladi.

Constant’ni funksiya ichida ham e’lon qilish mumkin.

Bu yerda message constant’i faqat main funksiyasi ichida ishlatiladi.

Agar constant faqat bitta funksiya ichida kerak bo‘lsa, uni aynan o‘sha funksiya ichida e’lon qilish yaxshi uslub hisoblanadi. Bu kodni tushunishni osonlashtiradi va qiymatning qayerda ishlatilishini aniq ko‘rsatadi.

bir nechta constan larni const block i ichida e'lon qilish mumkin:

Bu usul kodni tartibliroq qiladi.

Ayniqsa, bir xil mavzuga oid constant’lar ko‘p bo‘lsa, ularni bitta joyda guruhlab yozish o‘qishni osonlashtiradi.

Masalan:

Bu yerda barcha constant’lar foydalanuvchi statuslariga tegishli. Shuning uchun ularni bitta const bloki ichida yozish mantiqan to‘g‘ri bo'ladi.

Go’da constant oddiy o‘zgarmas variable emas. Constant qiymati dastur ishlashidan oldin, ya’ni compile time vaqtida ma’lum bo‘lishi kerak.

masalan:

Bu to‘g‘ri. Chunki 20 * 10 qiymatini kompilyator dastur ishga tushmasidan oldin hisoblay oladi.

Yana bir misol:

Bu ham to‘g‘ri. Chunki ikkita string literal’ni qo‘shish natijasi ham oldindan aniq.

Go’da constant asosan oddiy va compile time’da aniqlanadigan qiymatlar uchun ishlatiladi.

Constant sifatida quyidagi qiymatlarni e’lon qilish mumkin:

Bu misollarning barchasi to‘g‘ri.

Chunki ularning qiymati dastur ishga tushmasidan oldin ma’lum bo‘ladi.

Constant sifatida odatda quyidagi qiymatlar ishlatiladi:

Agar qiymat dasturning run time da aniqlansa, uni const bilan e’lon qilib bo‘lmaydi.

Masalan:

Bu xato. Chunki time.Now() qiymati dastur ishlayotgan paytda aniqlanadi. Kompilyator bu qiymatni oldindan bila olmaydi.

Bunday holatda var ishlatiladi:

Yana bir misol:

Bu ham noto‘g‘ri. Chunki slice constant bo‘la olmaydi.

Go’da constant’lar ikki xil bo‘lishi mumkin:

Bu farq constant’ning turi aniq ko‘rsatilgan yoki ko‘rsatilmaganiga bog‘liq.

Agar constant e’lon qilinayotganda uning turi alohida yozilmasa, u untyped constant hisoblanadi.

Masalan:

Bu yerda x constant’i uchun int, int64, float64 yoki boshqa tur aniq yozilmagan. Shuning uchun x — untyped constant.

Untyped constant literal’ga o‘xshab ishlaydi. Ya’ni u hali bitta aniq turga qattiq bog‘lanmagan bo‘ladi.

Shuning uchun bitta untyped numeric constant turli numeric type’larga moslashib ishlatilishi mumkin.

Masalan:

Bu kod to‘g‘ri ishlaydi.

Chunki x untyped constant bo‘lgani uchun Go uni kerakli joyda mos turga moslashtira oladi.

Bu yerda:

a — int;
b — int64;
c — float64;
d — byte.

Barcha holatda x qiymati 10 bo‘lgani uchun u shu turlarga sig‘adi va mos keladi.

Untyped constant’ning aniq turi bo‘lmaydi, lekin kerak bo‘lganda Go unga default type, ya’ni standart tur tanlaydi.

Masalan:

Bu yerda y uchun tur alohida yozilmagan. Shuning uchun Go x constant’iga default type tanlaydi.

Butun son constant’i uchun default type — int.

Demak, yuqoridagi misolda y ning turi int bo‘ladi.

Yana bir nechta misol:

Agar bu constant’lar aniq tur talab qilinmagan joyda ishlatilsa, Go ularga default type tanlaydi:

10 uchun — int;
3.14 uchun — float64;
"hello" uchun — string;
true uchun — bool.

Untyped constant moslashuvchan bo‘lsa ham, u istalgan turga avtomatik o‘tib ketavermaydi. Qiymat berilayotgan turga sig‘ishi va mos kelishi kerak.

Masalan:

Bu kod xato bo‘ladi. Chunki byte turi 0 dan 255 gacha bo‘lgan qiymatlarni saqlaydi. 300 esa byte turiga sig‘maydi.

Agar constant e’lon qilinayotganda uning turi aniq yozilsa, u typed constant hisoblanadi. 

Masalan:

Sahifa 01: Constant nima?
Sahifa 02: const bilan constant yaratish
Sahifa 03: Variable va constant farqi
Sahifa 04: Typed constants
Sahifa 05: Untyped constants
Sahifa 06: Constant expressions
Sahifa 07: Numeric constants
Sahifa 08: String constants
Sahifa 09: Boolean constants
Sahifa 10: iota
Sahifa 11: iota bilan enum-like qiymatlar
Sahifa 12: Common Mistakes va Best Practices
Sahifa 13: Amaliy mashqlar

oy

ce

bp

Sahifa 01: Expression nima?
Sahifa 02: Statement nima?
Sahifa 03: Arithmetic Operators
Sahifa 04: Assignment Operators
Sahifa 05: Comparison Operators
Sahifa 06: Logical Operators
Sahifa 07: Bitwise Operators
Sahifa 08: Increment va Decrement
Sahifa 09: Comparable Values
Sahifa 10: Operator Precedence
Sahifa 11: Expressionsni baholash
Sahifa 12: Common Mistakes va Best Practices
Sahifa 13: Amaliy mashqlar

Sahifa 01: Type Conversion nima?
Sahifa 02: Explicit conversion
Sahifa 03: Go'da implicit conversion yo'qligi
Sahifa 04: Numeric conversion
Sahifa 05: String conversion
Sahifa 06: strconv paketi
Sahifa 07: Type Alias
Sahifa 08: Defined Types
Sahifa 09: Underlying Type
Sahifa 10: Conversion Best Practices
Sahifa 11: Amaliy mashqlar

Sahifa 01: Type conversion nima?
Sahifa 02: Implicit va explicit conversion
Sahifa 03: Numeric conversion
Sahifa 04: String conversion
Sahifa 05: strconv paketi
Sahifa 06: Defined types
Sahifa 07: Type alias
Sahifa 08: Type conversion qoidalari
Sahifa 09: Amaliy mashqlar 

Sahifa 01: Control Flow nima?
• Kod bajarilish oqimi
• Sequential flow
• Conditional flow
• Loop flow
• Go’da control flow qanday ko‘rinadi?

Sahifa 02: if statement
• if nima?
• bool expression
• comparison operatorlar bilan ishlatish
• oddiy if misollari

Sahifa 03: if-else
• else nima?
• ikki holatli qaror
• true/false asosida kod ajratish

Sahifa 04: else if
• bir nechta shart
• shartlar tartibi
• birinchi true bo‘lgan branch ishlashi

Sahifa 05: Short statement in if
• if ichida variable yaratish
• scope
• Go’da ko‘p ishlatiladigan pattern

Sahifa 06: Guard Clause
• nested if’dan qochish
• early return
• kodni o‘qilishi oson qilish

Sahifa 07: Common Mistakes
• bool bo‘lmagan qiymatni if’da ishlatish
• = va == farqi
• ortiqcha nested if
• shadowing ehtiyotkorligi

Sahifa 08: Amaliy mashqlar

again:
Sahifa 01: Control Flow nima?
Sahifa 02: if statement
Sahifa 03: if-else
Sahifa 04: else if
Sahifa 05: Short statement in if
Sahifa 06: Guard Clause
Sahifa 07: Common Mistakes va Best Practices
Sahifa 08: Amaliy mashqlar

Bob 14: Control Flow — switch

Sahifa 01: switch statement
• switch nima?
• switch qachon ishlatiladi?
• if/else bilan farqi
• oddiy switch misoli

Sahifa 02: case va default
• case nima?
• default nima?
• case tartibi
• default yozish kerakmi?

Sahifa 03: Multiple values in case
• bitta case ichida bir nechta qiymat
• OR-like behavior
• kodni ixcham yozish

Sahifa 04: Expression switch
• switch expression bilan ishlashi
• string, int, bool qiymatlar bilan switch
• qiymatlarni solishtirish

Sahifa 05: Switch without expression
• expression’siz switch
• if/else chain o‘rnida ishlatish
• murakkab shartlarni chiroyli yozish

Sahifa 06: fallthrough
• Go’da case avtomatik break bo‘lishi
• fallthrough nima?
• qachon ishlatmaslik kerak?
• ehtiyotkorliklar

Sahifa 07: Type switch haqida kirish
• type switch nima?
• interface bilan bog‘liqligi
• hozircha qisqa preview
• batafsil Interfaces bobida

Sahifa 08: Common Mistakes va Best Practices
• ortiqcha fallthrough ishlatish
• if kerak joyda switch ishlatish
• default’ni unutish
• case’larni o‘qilishi oson tartibda yozish

Sahifa 09: Amaliy mashqlar



again
Sahifa 01: switch statement
Sahifa 02: case va default
Sahifa 03: Multiple values in case
Sahifa 04: Expression switch
Sahifa 05: Switch without expression
Sahifa 06: fallthrough
Sahifa 07: Type switch haqida kirish
Sahifa 08: Common Mistakes va Best Practices
Sahifa 09: Amaliy mashqlar

Sahifa 01: Loop nima?
Sahifa 02: Basic for loop
Sahifa 03: for as while
Sahifa 04: Infinite loop
Sahifa 05: break va continue
Sahifa 06: Nested loops
Sahifa 07: Labels bilan break va continue
Sahifa 08: Common Mistakes va Best Practices
Sahifa 09: Amaliy mashqlar

Sahifa 01: Function nima?
Sahifa 02: Function yaratish
Sahifa 03: Parameters
Sahifa 04: Return Values
Sahifa 05: Multiple Return Values
Sahifa 06: Named Return Values
Sahifa 07: Function Scope
Sahifa 08: Amaliy mashqlar

Sahifa 08: Common Mistakes va Best Practices

Sahifa 01: defer nima?
Sahifa 02: defer execution order
Sahifa 03: Multiple defer
Sahifa 04: Resource cleanup with defer
Sahifa 05: panic nima?
Sahifa 06: recover nima?
Sahifa 07: panic vs error
Sahifa 08: Common Mistakes va Best Practices
Sahifa 08: Amaliy mashqlar

Sahifa 01: Memory address nima?
Sahifa 02: Pointer nima?
Sahifa 03: & operator
Sahifa 04: * operator
Sahifa 05: Pointer orqali qiymatni o‘zgartirish
Sahifa 06: nil pointer
Sahifa 07: Pointer va Function
Sahifa 08: new function
Sahifa 09: Common Mistakes va Best Practices
Sahifa 09: Amaliy mashqlar

Sahifa 01: Array nima?
Sahifa 02: Array yaratish
Sahifa 03: Array length
Sahifa 04: Array indexing
Sahifa 05: Array literals
Sahifa 06: Array va for
Sahifa 07: Array va range
Sahifa 08: Array value sifatida uzatilishi
Sahifa 09: Amaliy mashqlar

Sahifa 01: Slice nima?
Sahifa 02: Slice yaratish
Sahifa 03: make bilan slice yaratish
Sahifa 04: append
Sahifa 05: len va cap
Sahifa 06: Slice internals
Sahifa 07: Slicing
Sahifa 08: copy
Sahifa 09: nil slice va empty slice
Sahifa 10: Slice va range
Sahifa 11: Common Mistakes va Best Practices
Sahifa 12: Amaliy mashqlar

Sahifa 01: String nima?
Sahifa 02: String va UTF-8
Sahifa 03: len(), indexing va slicing
Sahifa 04: for range va rune
Sahifa 05: string ↔ []byte
Sahifa 06: string ↔ []rune
Sahifa 07: strings package
Sahifa 08: strconv package
Sahifa 09: unicode/utf8 package
Sahifa 10: strings.Builder
Sahifa 11: Common Mistakes va Best Practices
Sahifa 12: Amaliy mashqlar

Sahifa 01: Map nima?
Sahifa 02: Key-value model
Sahifa 03: Map yaratish
Sahifa 04: make bilan map yaratish
Sahifa 05: Qiymat olish va o'zgartirish
Sahifa 06: Comma ok idiom
Sahifa 07: delete
Sahifa 08: map va range
Sahifa 09: Map key va comparable rule
Sahifa 10: nil map
Sahifa 11: Common Mistakes va Best Practices
Sahifa 12: Amaliy mashqlar

Sahifa 01: Struct nima?
Sahifa 02: Fields
Sahifa 03: Struct literal
Sahifa 04: Struct pointer
Sahifa 05: Nested struct
Sahifa 06: Anonymous struct
Sahifa 07: Embedded fields
Sahifa 08: Struct tags
Sahifa 09: Struct zero value
Sahifa 10: Struct comparison
Sahifa 11: Common Mistakes va Best Practices
Sahifa 12: Amaliy mashqlar

Sahifa 01: Method nima?
Sahifa 02: Function va method farqi
Sahifa 03: Receiver
Sahifa 04: Value receiver
Sahifa 05: Pointer receiver
Sahifa 06: Method set — kirish
Sahifa 07: Defined type bilan method
Sahifa 08: Common Mistakes va Best Practices
Sahifa 09: Amaliy mashqlar

Sahifa 01: Interface nima?
Sahifa 02: Interface qanday ishlaydi?
Sahifa 03: Implicit implementation
Sahifa 04: Small interfaces
Sahifa 05: Empty interface va any
Sahifa 06: Type assertion
Sahifa 07: Type switch
Sahifa 08: Nil interface muammosi
Sahifa 09: Real examples
Sahifa 09: Common Mistakes va Best Practices
Sahifa 10: Amaliy mashqlar

Sahifa 01: Variadic functions
Sahifa 02: Function values
Sahifa 03: Anonymous functions
Sahifa 04: Closures
Sahifa 05: Higher-order functions
Sahifa 06: Callback pattern
Sahifa 07: Recursion
Sahifa 08: Amaliy mashqlar


Sahifa 01: Variadic functions
Sahifa 02: Function values
Sahifa 03: Anonymous functions
Sahifa 04: Closures
Sahifa 05: Higher-order functions
Sahifa 06: Recursion
Sahifa 07: Closure ehtiyotkorliklari
Sahifa 08: Common Mistakes va Best Practices
Sahifa 09: Amaliy mashqlar

Sahifa 01: Generics nima?
Sahifa 02: Type parameters
Sahifa 03: Constraints
Sahifa 04: any constraint
Sahifa 05: comparable constraint
Sahifa 06: Type sets — kirish
Sahifa 07: Generic functions
Sahifa 08: Generic types
Sahifa 09: Generics qachon kerak?
Sahifa 10: Common Mistakes va Best Practices
Sahifa 11: Amaliy mashqlar

Sahifa 01: error nima?
Sahifa 02: Go'da exception yo'qligi
Sahifa 03: error qaytarish
Sahifa 04: errorni tekshirish
Sahifa 05: errors.New
Sahifa 06: fmt.Errorf
Sahifa 07: Error wrapping
Sahifa 08: errors.Is va errors.As
Sahifa 09: Sentinel error
Sahifa 10: Custom error
Sahifa 11: Common Mistakes va Best Practices
Sahifa 12: Amaliy mashqlar

Sahifa 01: Package nima?
Sahifa 02: Bitta folder — bitta package
Sahifa 03: package main va library package
Sahifa 04: import nima?
Sahifa 05: Import path qanday ishlaydi?
Sahifa 06: Standard package, local package va third-party package farqi
Sahifa 07: Import alias
Sahifa 08: Blank import va dot import haqida ehtiyotkorlik
Sahifa 09: Common Mistakes va Best Practices
Sahifa 10: Amaliy mashqlar

Sahifa 01: Module nima?
Sahifa 02: go mod init
Sahifa 03: go.mod
Sahifa 04: go.sum
Sahifa 05: Dependency nima?
Sahifa 06: go get
Sahifa 07: go mod tidy
Sahifa 08: Module path
Sahifa 09: Common Mistakes va Best Practices
Sahifa 10: Amaliy mashqlar

Sahifa 01: Library package nima?
Sahifa 02: Package folder yaratish
Sahifa 03: Package ichida function yozish
Sahifa 04: Bir package ichida bir nechta .go file
Sahifa 05: Local package’ni import qilish
Sahifa 06: Package nomi va folder nomi
Sahifa 07: Import cycle nima?
Sahifa 08: Kichik calculator package yaratish
Sahifa 09: Common Mistakes va Best Practices
Sahifa 10: Amaliy mashqlar

Sahifa 01: Standard Library nima?
Sahifa 02: fmt, log, slog
Sahifa 03: strings, strconv, unicode
Sahifa 04: os, io, bufio
Sahifa 05: encoding packages
Sahifa 06: time
Sahifa 07: sort, slices, maps, cmp
Sahifa 08: sync va context
Sahifa 09: testing
Sahifa 10: Standard Library’ni o'qish usuli

Sahifa 01: fmt package nima?
Sahifa 02: Print, Println, Printf
Sahifa 03: Formatting verbs: %v, %s, %d, %f, %T
Sahifa 04: Sprintf bilan string yaratish
Sahifa 05: log package
Sahifa 06: log/slog haqida qisqa kirish
Sahifa 07: Common Mistakes va Best Practices
Sahifa 08: Amaliy mashqlar

Sahifa 01: strings package
Sahifa 02: Contains, HasPrefix, HasSuffix
Sahifa 03: Split va Join
Sahifa 04: Replace va Trim
Sahifa 05: strconv package
Sahifa 06: unicode package
Sahifa 07: unicode/utf8 package
Sahifa 08: regexp basics
Sahifa 09: Common Mistakes va Best Practices
Sahifa 10: Amaliy mashqlar

Sahifa 01: sort package
Sahifa 02: Custom sort
Sahifa 03: slices package
Sahifa 04: slices.Contains
Sahifa 05: slices.Sort
Sahifa 06: maps package
Sahifa 07: maps.Clone
Sahifa 08: cmp package
Sahifa 09: Common Mistakes va Best Practices
Sahifa 10: Amaliy mashqlar

Sahifa 01: time package
Sahifa 02: time.Now()
Sahifa 03: time.Time
Sahifa 04: Time formatting
Sahifa 05: Time parsing
Sahifa 06: Duration
Sahifa 07: Timer va Ticker
Sahifa 08: Timezone — kirish
Sahifa 09: Common Mistakes va Best Practices
Sahifa 10: Amaliy mashqlar

Sahifa 01: os package
Sahifa 02: File yaratish
Sahifa 03: File ochish
Sahifa 04: File o'qish
Sahifa 05: File yozish
Sahifa 06: os.ReadFile va os.WriteFile
Sahifa 07: path/filepath
Sahifa 08: Temporary files
Sahifa 09: Common Mistakes va Best Practices
Sahifa 10: Amaliy mashqlar

Sahifa 01: io.Reader
Sahifa 02: io.Writer
Sahifa 03: io.Copy
Sahifa 04: io.EOF
Sahifa 05: bytes.Buffer
Sahifa 06: strings.Reader
Sahifa 07: bufio.Reader va Writer
Sahifa 08: bufio.Scanner
Sahifa 09: Common Mistakes va Best Practices
Sahifa 10: Amaliy mashqlar

Sahifa 01: JSON nima?
Sahifa 02: encoding/json
Sahifa 03: Marshal
Sahifa 04: Unmarshal
Sahifa 05: Struct tags
Sahifa 06: Nested JSON
Sahifa 07: Decoder va Encoder
Sahifa 08: map[string]any
Sahifa 09: csv va xml — kirish
Sahifa 10: Common Mistakes va Best Practices
Sahifa 11: Amaliy mashqlar

Sahifa 01: log package
Sahifa 02: log/slog — kirish
Sahifa 03: os.Args
Sahifa 04: flag package
Sahifa 05: Command-line arguments
Sahifa 06: Environment variables
Sahifa 07: os.Getenv
Sahifa 08: Amaliy CLI misol
Sahifa 09: Common Mistakes va Best Practices
Sahifa 10: Amaliy mashqlar

Sahifa 01: math package
Sahifa 02: math.Round, Floor, Ceil
Sahifa 03: math/rand
Sahifa 04: crypto/rand farqi
Sahifa 05: hash tushunchasi
Sahifa 06: sha256
Sahifa 07: encoding/base64
Sahifa 08: Common Mistakes va Best Practices
Sahifa 09: Amaliy mashqlar

Sahifa 01: Concurrency nima?
Sahifa 02: Parallelism nima?
Sahifa 03: Concurrency va parallelism farqi
Sahifa 04: Blocking tushunchasi
Sahifa 05: Race condition — kirish
Sahifa 06: Go scheduler — sodda tushuncha
Sahifa 07: Common Mistakes va Best Practices
Sahifa 08: Amaliy mashqlar

Sahifa 01: Goroutine nima?
Sahifa 02: go keyword
Sahifa 03: Main goroutine
Sahifa 04: Goroutine lifecycle
Sahifa 05: Goroutine qachon tugaydi?
Sahifa 06: time.Sleep bilan noto'g'ri kutish
Sahifa 07: Goroutine leak — kirish
Sahifa 08: Common Mistakes va Best Practices
Sahifa 09: Amaliy mashqlar

Sahifa 01: Channel nima?
Sahifa 02: Channel yaratish
Sahifa 03: Send va receive
Sahifa 04: Unbuffered channel
Sahifa 05: Buffered channel
Sahifa 06: close
Sahifa 07: range over channel
Sahifa 08: Directional channels
Sahifa 09: Common Mistakes va Best Practices
Sahifa 10: Amaliy mashqlar

Sahifa 01: select nima?
Sahifa 02: Multiple channels
Sahifa 03: default case
Sahifa 04: Timeout
Sahifa 05: done channel
Sahifa 06: Cancellation — kirish
Sahifa 07: Common Mistakes va Best Practices
Sahifa 08: Amaliy mashqlar

Sahifa 01: sync package
Sahifa 02: WaitGroup
Sahifa 03: Mutex
Sahifa 04: RWMutex
Sahifa 05: Once
Sahifa 06: Cond — kirish
Sahifa 07: Pool — kirish
Sahifa 08: sync.Map — kirish
Sahifa 09: Common Mistakes va Best Practices
Sahifa 10: Amaliy mashqlar

Sahifa 01: Race condition
Sahifa 02: Data race
Sahifa 03: go test -race — kirish
Sahifa 04: sync/atomic
Sahifa 05: Atomic counter
Sahifa 06: Mutex va atomic farqi
Sahifa 07: Atomic qachon kerak?
Sahifa 08: Common Mistakes va Best Practices
Sahifa 09: Amaliy mashqlar

Sahifa 01: context nima?
Sahifa 02: context.Background
Sahifa 03: context.TODO
Sahifa 04: WithCancel
Sahifa 05: WithTimeout
Sahifa 06: WithDeadline
Sahifa 07: context value
Sahifa 08: Contextdan noto'g'ri foydalanish
Sahifa 09: Common Mistakes va Best Practices
Sahifa 10: Amaliy mashqlar

Sahifa 01: Worker pool
Sahifa 02: Pipeline
Sahifa 03: Fan-out
Sahifa 04: Fan-in
Sahifa 05: Semaphore pattern
Sahifa 06: Rate limit — kirish
Sahifa 07: Graceful shutdown — kirish
Sahifa 08: Goroutine leak oldini olish
Sahifa 09: Common Mistakes va Best Practices
Sahifa 10: Amaliy loyiha

Sahifa 01: go command
Sahifa 02: go help
Sahifa 03: go run
Sahifa 04: go build
Sahifa 05: go install
Sahifa 06: go clean
Sahifa 07: go version
Sahifa 08: go list — kirish

Sahifa 01: Binary nomini belgilash
Sahifa 02: Build output
Sahifa 03: GOOS
Sahifa 04: GOARCH
Sahifa 05: Cross-compilation
Sahifa 06: Build tags
Sahifa 07: ldflags — kirish
Sahifa 08: Amaliy mashqlar

Sahifa 01: gofmt
Sahifa 02: go fmt
Sahifa 03: go vet
Sahifa 04: go fix — kirish
Sahifa 05: Static analysis
Sahifa 06: Linter nima?
Sahifa 07: Kod sifatini tekshirish odati

Sahifa 01: go.mod chuqurroq
Sahifa 02: go.sum chuqurroq
Sahifa 03: go get
Sahifa 04: go mod tidy
Sahifa 05: go mod download
Sahifa 06: go mod graph
Sahifa 07: replace
Sahifa 08: exclude
Sahifa 09: vendor
Sahifa 10: Private modules — kirish

Sahifa 01: Workspace nima?
Sahifa 02: go work init
Sahifa 03: go work use
Sahifa 04: go.work
Sahifa 05: Multiple modules
Sahifa 06: Monorepo — kirish
Sahifa 07: Workspace qachon kerak emas?
Sahifa 08: Amaliy mashqlar

Sahifa 01: Go documentation culture
Sahifa 02: Documentation comments
Sahifa 03: Exported names comments
Sahifa 04: go doc
Sahifa 05: pkg.go.dev
Sahifa 06: Example orqali documentation
Sahifa 07: Package documentation
Sahifa 08: Amaliy mashqlar

Sahifa 01: go env
Sahifa 02: GOROOT
Sahifa 03: GOPATH
Sahifa 04: GOMODCACHE
Sahifa 05: Build cache
Sahifa 06: Test cache
Sahifa 07: GOPROXY
Sahifa 08: GOSUMDB
Sahifa 09: Environment muammolarini tekshirish

Sahifa 01: go generate
Sahifa 02: //go:generate
Sahifa 03: Code generation qachon kerak?
Sahifa 04: embed package
Sahifa 05: //go:embed
Sahifa 06: Faylni binary ichiga qo'shish
Sahifa 07: embed bilan CLI misol
Sahifa 08: Amaliy mashqlar

Sahifa 01: Oddiy Go project structure
Sahifa 02: Single package project
Sahifa 03: main package va library package
Sahifa 04: cmd folder
Sahifa 05: internal folder
Sahifa 06: testdata folder
Sahifa 07: examples folder
Sahifa 08: Overengineeringdan qochish
Sahifa 09: Amaliy loyiha strukturasi

p

Sahifa 01: Table-driven test nima?
Sahifa 02: Test case struct
Sahifa 03: for loop bilan test
Sahifa 04: t.Run
Sahifa 05: Subtests
Sahifa 06: Parallel subtests — kirish
Sahifa 07: Test naming
Sahifa 08: Amaliy mashqlar

Sahifa 01: Helper function
Sahifa 02: t.Helper()
Sahifa 03: Setup va teardown
Sahifa 04: t.TempDir()
Sahifa 05: testdata folder
Sahifa 06: Golden file testing
Sahifa 07: Natijalarni taqqoslash
Sahifa 08: Amaliy mashqlar

Sahifa 01: Benchmark nima?
Sahifa 02: BenchmarkXxx function
Sahifa 03: b.N
Sahifa 04: go test -bench
Sahifa 05: b.ReportAllocs
Sahifa 06: Allocation o'lchash
Sahifa 07: Microbenchmark xatolari
Sahifa 08: Amaliy mashqlar

Sahifa 01: Coverage nima?
Sahifa 02: go test -cover
Sahifa 03: Coverage profile
Sahifa 04: HTML coverage
Sahifa 05: 100% coverage har doim maqsad emas
Sahifa 06: Muhim test yozish
Sahifa 07: Amaliy mashqlar

Sahifa 01: Example test
Sahifa 02: ExampleXxx function
Sahifa 03: Output comment
Sahifa 04: Documentation bilan bog'liq testlar
Sahifa 05: Fuzz testing
Sahifa 06: FuzzXxx function
Sahifa 07: Fuzz test qachon foydali?
Sahifa 08: Amaliy mashqlar

Sahifa 01: Concurrent kodni testlash qiyinligi
Sahifa 02: go test -race
Sahifa 03: Timeout bilan testlash
Sahifa 04: Flaky test
Sahifa 05: Channel bilan test
Sahifa 06: Context bilan test
Sahifa 07: Race condition topish
Sahifa 08: Amaliy mashqlar

Sahifa 01: Mock nima?
Sahifa 02: Fake nima?
Sahifa 03: Stub nima?
Sahifa 04: Interface orqali testlash
Sahifa 05: Test uchun kichik interface
Sahifa 06: Unit test va integration test farqi
Sahifa 07: Tashqi kutubxonasiz test yozish
Sahifa 08: Amaliy mashqlar

Sahifa 01: Idiom nima?
Sahifa 02: Gocha kod yozish
Sahifa 03: Simplicity
Sahifa 04: Explicit code
Sahifa 05: Kamroq abstraction
Sahifa 06: Go kodini o'qish madaniyati

Sahifa 01: Go naming philosophy
Sahifa 02: Qisqa nomlar
Sahifa 03: Uzoq nom qachon kerak?
Sahifa 04: Package names
Sahifa 05: Interface names
Sahifa 06: Exported names
Sahifa 07: Comment style
Sahifa 08: Amaliy mashqlar

Sahifa 01: Early return
Sahifa 02: Guard clause
Sahifa 03: Nested iflardan qochish
Sahifa 04: Errorni erta qaytarish
Sahifa 05: Readable flow
Sahifa 06: Before/after refactoring
Sahifa 07: Amaliy mashqlar

Sahifa 01: Errorni yashirmaslik
Sahifa 02: Errorni darhol tekshirish
Sahifa 03: Error wrapping culture
Sahifa 04: Sentinel error qachon kerak?
Sahifa 05: Custom error qachon kerak?
Sahifa 06: panicdan qochish
Sahifa 07: Error message style
Sahifa 08: Amaliy mashqlar

Sahifa 01: Small interfaces
Sahifa 02: Interface'ni consumer tomonda yozish
Sahifa 03: Accept interfaces, return structs
Sahifa 04: Empty interface'dan ehtiyot bo'lish
Sahifa 05: any qachon kerak?
Sahifa 06: Interface ortiqcha ishlatilganda
Sahifa 07: Amaliy mashqlar

Sahifa 01: Go'da inheritance yo'q
Sahifa 02: Composition
Sahifa 03: Embedding
Sahifa 04: Zero value foydali bo'lishi
Sahifa 05: Constructor function qachon kerak?
Sahifa 06: Config struct
Sahifa 07: Functional options — kirish
Sahifa 08: Amaliy mashqlar

Sahifa 01: Channel ownership
Sahifa 02: Channelni kim yopadi?
Sahifa 03: Close signal sifatida
Sahifa 04: Context bilan cancellation
Sahifa 05: Goroutine leakdan qochish
Sahifa 06: Shared memory vs message passing
Sahifa 07: Worker pool idiomi
Sahifa 08: Amaliy mashqlar

Sahifa 01: Kichik package yozish
Sahifa 02: Public API'ni toza saqlash
Sahifa 03: internal package ishlatish
Sahifa 04: Circular dependencydan qochish
Sahifa 05: Package name va API name takrorlanmasligi
Sahifa 06: Minimal dependency
Sahifa 07: Amaliy refactoring

Sahifa 01: Readable code nima?
Sahifa 02: Clever codedan qochish
Sahifa 03: Kichik functions
Sahifa 04: Takroriy kodni to'g'ri ajratish
Sahifa 05: Refactoring qachon kerak?
Sahifa 06: Code review checklist
Sahifa 07: Amaliy mashqlar

Sahifa 01: Stack
Sahifa 02: Heap
Sahifa 03: Local variables qayerda yashaydi?
Sahifa 04: Pointer va allocation
Sahifa 05: Stack growth
Sahifa 06: Heap allocation narxi
Sahifa 07: Amaliy misollar

Sahifa 01: Escape analysis
Sahifa 02: Qiymat qachon heapga chiqadi?
Sahifa 03: Pointer qaytarish misoli
Sahifa 04: Interface va escape
Sahifa 05: go build -gcflags=-m
Sahifa 06: Natijalarni o'qish
Sahifa 07: Amaliy mashqlar

Sahifa 01: Garbage Collector
Sahifa 02: Automatic memory management
Sahifa 03: Allocation va GC bog'liqligi
Sahifa 04: GC pause
Sahifa 05: GOGC — kirish
Sahifa 06: Allocationni kamaytirish
Sahifa 07: Amaliy maslahatlar

Sahifa 01: Memory model nima?
Sahifa 02: Happens-before
Sahifa 03: Channel va memory synchronization
Sahifa 04: Mutex va memory synchronization
Sahifa 05: Atomic va memory ordering
Sahifa 06: Data race nimaga xavfli?
Sahifa 07: Amaliy misollar

Sahifa 01: Scheduler nima?
Sahifa 02: M, P, G model — kirish
Sahifa 03: Goroutine scheduling
Sahifa 04: Blocking syscall
Sahifa 05: Network polling — kirish
Sahifa 06: Preemption — kirish
Sahifa 07: GOMAXPROCS
Sahifa 08: Amaliy tushuntirish

Sahifa 01: Profiling nima?
Sahifa 02: Benchmark va profiling farqi
Sahifa 03: pprof — kirish
Sahifa 04: CPU profiling
Sahifa 05: Memory profiling
Sahifa 06: Goroutine profiling
Sahifa 07: Blocking profiling
Sahifa 08: Natijalarni o'qish
Sahifa 09: Amaliy mashqlar

Sahifa 01: Avval o'lchash, keyin optimize qilish
Sahifa 02: Allocation kamaytirish
Sahifa 03: Slice capacity oldindan berish
Sahifa 04: strings.Builder
Sahifa 05: bytes.Buffer
Sahifa 06: sync.Pool ehtiyotkorliklari
Sahifa 07: Premature optimizationdan qochish
Sahifa 08: Amaliy refactoring

Sahifa 01: runtime package
Sahifa 02: runtime/debug
Sahifa 03: Stack trace o'qish
Sahifa 04: Panic stack trace
Sahifa 05: runtime/metrics — kirish
Sahifa 06: trace — kirish
Sahifa 07: Muammo topish tartibi

Sahifa 01: Reflection nima?
Sahifa 02: reflect paketi
Sahifa 03: reflect.Type
Sahifa 04: reflect.Value
Sahifa 05: Struct fieldlarini o'qish
Sahifa 06: Methodlarni ko'rish
Sahifa 07: Struct taglar va reflection
Sahifa 08: Reflection qachon kerak?
Sahifa 09: Reflection qachon kerak emas?
Sahifa 10: Amaliy mashqlar

Sahifa 01: unsafe nima?
Sahifa 02: unsafe.Pointer
Sahifa 03: uintptr
Sahifa 04: unsafe.Sizeof
Sahifa 05: unsafe.Alignof
Sahifa 06: unsafe.Offsetof
Sahifa 07: unsafe xavflari
Sahifa 08: unsafe qachon kerak bo'lishi mumkin?
Sahifa 09: unsafe ishlatmaslik kerak bo'lgan holatlar

Sahifa 01: CGo nima?
Sahifa 02: Go va C bog'lanishi
Sahifa 03: Oddiy C funksiyasini chaqirish
Sahifa 04: C type va Go type
Sahifa 05: Memory ownership masalasi
Sahifa 06: CGo performance narxi
Sahifa 07: Portability muammolari
Sahifa 08: CGo qachon kerak?
Sahifa 09: CGo qachon kerak emas?

Sahifa 01: Build constraint nima?
Sahifa 02: //go:build
Sahifa 03: OS bo'yicha fayl ajratish
Sahifa 04: Architecture bo'yicha fayl ajratish
Sahifa 05: //go:generate qayta ko'rish
Sahifa 06: //go:embed qayta ko'rish
Sahifa 07: Compiler directive haqida ehtiyotkorlik
Sahifa 08: Amaliy mashqlar

Sahifa 01: Functional options
Sahifa 02: Builderga o'xshash uslub
Sahifa 03: Pipeline pattern
Sahifa 04: Retry pattern
Sahifa 05: Cancellation pattern
Sahifa 06: Iterator uslubi
Sahifa 07: Plugin-like design haqida kirish
Sahifa 08: Patternlarni ortiqcha ishlatmaslik
Sahifa 09: Amaliy mashqlar

Sahifa 01: Go versiyalari qanday chiqadi?
Sahifa 02: Backward compatibility
Sahifa 03: Eski kod va yangi Go
Sahifa 04: Release notes o'qish
Sahifa 05: Yangi featurelarni baholash
Sahifa 06: Loyihani yangi versiyaga ko'tarish
Sahifa 07: Go kodini uzoq muddat saqlash