0 / 12
🐹
Dars 01

Go tiliga Kirish

Go (yoki Golang) — Google tomonidan 2009-yilda yaratilgan, tezkor, sodda va samarali dasturlash tili. Server, cloud, va microservice ilovalar uchun juda mashhur.

⚡ Tezlik

C/C++ ga yaqin tezlikda ishlaydi, lekin Python kabi yozish oson.

🔒 Xavfsiz

Statik typli, garbage collection bor — memory muammolari kam.

🔀 Concurrency

Goroutine orqali bir vaqtda minglab operatsiyalar bajarish mumkin.

📦 Sodda

Faqat 25 ta kalit so'z — o'rganish juda oson!

O'rnatish

Go ni rasmiy saytdan yuklab oling: go.dev/dl

$ terminal 
# Versiyani tekshirish
go version
# Natija: go version go1.22.0 linux/amd64

# Yangi proyekt yaratish
mkdir mening-loyiham
cd mening-loyiham
go mod init mening-loyiham

Go fayl tuzilmasi

main.go
package main   // har bir dastur main packagedan boshlanadi

import "fmt"   // fmt — formatlash kutubxonasi

func main() {  // dastur shu yerdan boshlanadi
    fmt.Println("Salom, Dunyo!")
}
Natija
Salom, Dunyo!
Go'da har bir fayl package nomi bilan boshlanadi. Bajariladigan dasturlar uchun albatta package main bo'lishi kerak.
Dars 02

Hello World va Dastur Ishlatish

Go dasturini yozish, kompilyatsiya qilish va ishga tushirishni o'rganamiz.

Dasturni ishga tushirish

$ terminal 
# To'g'ridan to'g'ri ishga tushirish
go run main.go

# Kompilyatsiya qilib binary yaratish
go build -o dastur main.go
./dastur

fmt paketi bilan ishlash

main.go
package main

import "fmt"

func main() {
    // Println — yangi satr bilan chiqaradi
    fmt.Println("Salom, Go!")

    // Printf — formatlangan chiqarish
    fmt.Printf("Yosh: %d, Ism: %s\n", 25, "Ali")

    // Sprintf — string hosil qiladi
    xabar := fmt.Sprintf("Harorat: %.1f°C", 36.6)
    fmt.Println(xabar)
}
Natija
Salom, Go! Yosh: 25, Ism: Ali Harorat: 36.6°C

Format belgilari (Verbs)

Verb Ma'nosi Misol
%d Butun son fmt.Printf("%d", 42) → 42
%f Float son fmt.Printf("%.2f", 3.14) → 3.14
%s String fmt.Printf("%s", "salom") → salom
%v Har qanday qiymat fmt.Printf("%v", true) → true
%T Tur nomi fmt.Printf("%T", 5) → int
%t Boolean fmt.Printf("%t", false) → false
Dars 03

O'zgaruvchilar (Variables)

Go'da o'zgaruvchi e'lon qilishning bir necha usuli bor. Har birini misollar bilan ko'ramiz.

variables.go
package main
import "fmt"

func main() {
    // 1-usul: var kalit so'zi bilan
    var ism string = "Kamol"
    var yosh int = 22

    // 2-usul: turni avtomatik aniqlash
    var shahar = "Toshkent"

    // 3-usul: qisqa e'lon (:=) — eng ko'p ishlatiladigan
    narx := 150000.50
    aktiv := true

    // Bir nechta o'zgaruvchi bir vaqtda
    x, y, z := 1, 2, 3

    // Konstantalar (o'zgarmaydigan)
    const PI = 3.14159
    const SAYT = "golang.org"

    fmt.Println(ism, yosh, shahar)
    fmt.Println(narx, aktiv)
    fmt.Println(x, y, z)
    fmt.Println(PI, SAYT)
}
Natija
Kamol 22 Toshkent 150000.5 true 1 2 3 3.14159 golang.org
Go'da e'lon qilingan o'zgaruvchi ishlatilmasa, kompilyatsiya xatosi beradi! Bu tilning muhim xususiyatlaridan biri.

Nol qiymatlar (Zero Values)

zero.go
var a int     // 0
var b float64 // 0.0
var c string  // "" (bo'sh string)
var d bool    // false
❓ Go'da qisqa o'zgaruvchi e'lon qilish uchun qaysi operator ishlatiladi?
Dars 04

Ma'lumot Turlari

Go statik tipli til — har bir o'zgaruvchining turi kompilyatsiya vaqtida aniq bo'lishi kerak.

Asosiy turlar

Tur O'lcham Diapazon / Misol
int 32/64-bit -2^63 dan 2^63-1 gacha
int8 8-bit -128 dan 127
int16 16-bit -32768 dan 32767
int32 (rune) 32-bit Unicode belgi
int64 64-bit Katta sonlar uchun
float32 32-bit 3.14
float64 64-bit 3.141592653589793
string — "Salom Go"
bool 1-bit true / false
byte (uint8) 8-bit 0 dan 255
types.go
package main
import "fmt"

func main() {
    // Turni ko'rsatish
    a := 42
    b := 3.14
    c := "salom"
    d := true

    fmt.Printf("%T = %v\n", a, a) // int = 42
    fmt.Printf("%T = %v\n", b, b) // float64 = 3.14
    fmt.Printf("%T = %v\n", c, c) // string = salom
    fmt.Printf("%T = %v\n", d, d) // bool = true

    // Tur o'zgartirish (Type Conversion)
    son := 42
    float := float64(son)
    matn := string([]byte("A"))

    fmt.Println(float, matn)

    // String uzunligi
    s := "Go tili"
    fmt.Println(len(s)) // 7
}
Natija
int = 42 float64 = 3.14 string = salom bool = true 42 A 7
Go'da turlar orasida avtomatik konversiya bo'lmaydi! int ni float64 ga aylantirish uchun float64(son) deb yozish kerak.
Dars 05

Operatorlar

Go'da arifmetik, taqqoslash va mantiqiy operatorlar.

operators.go
package main
import "fmt"

func main() {
    // Arifmetik operatorlar
    a, b := 10, 3
    fmt.Println(a + b)  // 13  (qo'shish)
    fmt.Println(a - b)  // 7   (ayirish)
    fmt.Println(a * b)  // 30  (ko'paytirish)
    fmt.Println(a / b)  // 3   (bo'lish)
    fmt.Println(a % b)  // 1   (qoldiq)

    // Taqqoslash operatorlari — bool qaytaradi
    fmt.Println(a == b) // false
    fmt.Println(a != b) // true
    fmt.Println(a > b)  // true
    fmt.Println(a <= b) // false

    // Mantiqiy operatorlar
    x, y := true, false
    fmt.Println(x && y)  // false (VA)
    fmt.Println(x || y)  // true  (YOKI)
    fmt.Println(!x)     // false (EMAS)

    // Qisqa yozuv operatorlari
    n := 5
    n += 3   // n = n + 3 = 8
    n++       // n = n + 1 = 9
    n--       // n = n - 1 = 8
    fmt.Println(n)
}
Natija
13 7 30 3 1 false true true false false true false 8
Dars 06

if / else Shartli Operatorlar

Dasturda qaror qabul qilish — if, else if, else konstruktsiyalari.

conditions.go
package main
import "fmt"

func main() {
    ball := 75

    // Oddiy if-else
    if ball >= 90 {
        fmt.Println("A'lo")
    } else if ball >= 70 {
        fmt.Println("Yaxshi")
    } else if ball >= 55 {
        fmt.Println("Qoniqarli")
    } else {
        fmt.Println("Qoniqarsiz")
    }

    // if bilan qisqa e'lon (scope ichida)
    if toq := ball % 2; toq != 0 {
        fmt.Println("Toq son")
    } else {
        fmt.Println("Juft son")
    }

    // Murakkab shart
    yosh := 20
    pul := 500000
    if yosh >= 18 && pul >= 100000 {
        fmt.Println("Kreditga ruxsat bor")
    }
}
Natija
Yaxshi Toq son Kreditga ruxsat bor
Go'da if shartida qavslar () kerak emas, lekin figurali qavslar { } majburiy!
Dars 07

for Sikli

Go'da faqat for sikli bor — u while va do-while o'rnini ham bosadi!

loops.go
package main
import "fmt"

func main() {
    // 1. Klassik for sikli
    for i := 0; i < 5; i++ {
        fmt.Printf("%d ", i)
    }
    fmt.Println()

    // 2. While kabi ishlash
    n := 1
    for n <= 8 {
        fmt.Printf("%d ", n)
        n *= 2
    }
    fmt.Println()

    // 3. Cheksiz sikl + break
    count := 0
    for {
        count++
        if count == 3 { break }
    }
    fmt.Println("Count:", count)

    // 4. continue — o'tkazib yuborish
    for i := 1; i <= 6; i++ {
        if i%2 == 0 { continue }
        fmt.Printf("%d ", i)
    }
    fmt.Println()

    // 5. range — slice/array ichida yurish
    mevalar := []string{"olma", "nok", "uzum"}
    for i, meva := range mevalar {
        fmt.Printf("%d: %s\n", i, meva)
    }
}
Natija
0 1 2 3 4 1 2 4 8 Count: 3 1 3 5 0: olma 1: nok 2: uzum
Dars 08

switch Operatori

Go'da switch — if/else if zanjiridan ancha toza va qulay variant.

switch.go
package main
import "fmt"

func main() {
    kun := 3

    // Oddiy switch
    switch kun {
    case 1:
        fmt.Println("Dushanba")
    case 2:
        fmt.Println("Seshanba")
    case 3:
        fmt.Println("Chorshanba")
    case 4, 5:
        fmt.Println("Payshanba yoki Juma")
    default:
        fmt.Println("Dam olish kuni")
    }

    // Shartsiz switch (if-else o'rniga)
    ball := 85
    switch {
    case ball >= 90:
        fmt.Println("A'lo (5)")
    case ball >= 70:
        fmt.Println("Yaxshi (4)")
    case ball >= 55:
        fmt.Println("Qoniqarli (3)")
    default:
        fmt.Println("Qoniqarsiz (2)")
    }

    // Tur tekshirish (type switch)
    var qiymat interface{} = "salom"
    switch v := qiymat.(type) {
    case int:
        fmt.Printf("int: %d\n", v)
    case string:
        fmt.Printf("string: %s\n", v)
    case bool:
        fmt.Printf("bool: %t\n", v)
    }
}
Natija
Chorshanba Yaxshi (4) string: salom
Go'da switch ichida break yozish shart emas — har bir case avtomatik to'xtaydi. Keyingi casega o'tish uchun fallthrough kalit so'zi ishlatiladi.
Dars 09

Funksiyalar (Functions)

Go'da funksiyalar — kodni modulga bo'lish va qayta ishlatish imkoni. Bir nechta qiymat qaytarish kabi kuchli xususiyatlar bor.

functions.go
package main
import "fmt"

// Oddiy funksiya
func salom(ism string) string {
    return "Salom, " + ism + "!"
}

// Bir nechta parametr
func yig'indi(a, b int) int {
    return a + b
}

// Ko'p qiymat qaytarish (Go ning kuchli tomoni!)
func bo'lish(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("nolga bo'lish xatosi")
    }
    return a / b, nil
}

// Variadic funksiya (ixtiyoriy miqdorda argument)
func jami(sonlar ...int) int {
    summa := 0
    for _, s := range sonlar {
        summa += s
    }
    return summa
}

func main() {
    fmt.Println(salom("Dilnoza"))
    fmt.Println(yig'indi(15, 27))

    natija, xato := bo'lish(10, 3)
    if xato != nil {
        fmt.Println("Xato:", xato)
    } else {
        fmt.Printf("%.4f\n", natija)
    }

    fmt.Println(jami(1, 2, 3, 4, 5))

    // Anonim funksiya (lambda)
    kvadrat := func(x int) int { return x * x }
    fmt.Println(kvadrat(7))
}
Natija
Salom, Dilnoza! 42 3.3333 15 49
Go'da funksiyalar birinchi darajali qiymat — ularni o'zgaruvchiga saqlash, argument sifatida uzatish va qaytarish mumkin!
Dars 10

Array, Slice va Map

Go'da ma'lumotlar to'plamini saqlash uchun array (qat'iy o'lchamli), slice (dinamik) va map (kalit-qiymat) ishlatiladi.

collections.go
package main
import "fmt"

func main() {
    // ═══ ARRAY (qat'iy o'lcham) ═══
    var sonlar [5]int = [5]int{10, 20, 30, 40, 50}
    fmt.Println(sonlar[0], sonlar[2])

    // ═══ SLICE (dinamik, ko'p ishlatiladigan) ═══
    mevalar := []string{"olma", "nok", "gilos"}

    // Qo'shish
    mevalar = append(mevalar, "shaftoli", "qovun")
    fmt.Println(mevalar)
    fmt.Println("Uzunlik:", len(mevalar))

    // Slicing (kesma olish)
    fmt.Println(mevalar[1:4]) // [nok gilos shaftoli]
    fmt.Println(mevalar[:2])  // [olma nok]

    // make bilan slice yaratish
    raqamlar := make([]int, 3, 5) // uzunlik=3, sig'im=5
    fmt.Println(raqamlar)

    // ═══ MAP (kalit → qiymat) ═══
    talaba := map[string]int{
        "matematika": 95,
        "fizika":     87,
        "inglizcha":  92,
    }

    fmt.Println(talaba["matematika"])

    // Yangi qiymat qo'shish
    talaba["kimyo"] = 78

    // Mavjudligini tekshirish
    ball, mavjud := talaba["biologiya"]
    if !mavjud {
        fmt.Println("Biologiya topilmadi, default:", ball)
    }

    // Barcha kalit-qiymatlarni ko'rish
    for fan, baho := range talaba {
        fmt.Printf("%s: %d\n", fan, baho)
    }

    // O'chirish
    delete(talaba, "kimyo")
}
Natija
10 30 [olma nok gilos shaftoli qovun] Uzunlik: 5 [nok gilos shaftoli] [olma nok] [0 0 0] 95 Biologiya topilmadi, default: 0
Dars 11

Struct va Metodlar

Struct — Go'da obyektga o'xshash tuzilma. Metodlar orqali unga funksionallik qo'shish mumkin.

structs.go
package main
import "fmt"

// Struct e'loni
type Talaba struct {
    Ism     string
    Yosh    int
    Baholar []int
}

// Metod — (receiver bilan funksiya)
func (t Talaba) OrtachaBalll() float64 {
    if len(t.Baholar) == 0 { return 0 }
    summa := 0
    for _, b := range t.Baholar {
        summa += b
    }
    return float64(summa) / float64(len(t.Baholar))
}

// Pointer receiver — o'zgartirishlar saqlanadi
func (t *Talaba) BaholarQo'sh(baho int) {
    t.Baholar = append(t.Baholar, baho)
}

func (t Talaba) Taqdim() string {
    return fmt.Sprintf("%s (%d yosh) — o'rtacha: %.1f",
        t.Ism, t.Yosh, t.OrtachaBalll())
}

func main() {
    // Struct yaratish
    ali := Talaba{
        Ism:  "Ali Karimov",
        Yosh: 20,
    }

    ali.BaholarQo'sh(88)
    ali.BaholarQo'sh(95)
    ali.BaholarQo'sh(76)

    fmt.Println(ali.Taqdim())

    // Struct array
    guruh := []Talaba{
        {"Zulfiya", 19, []int{90, 85}},
        {"Bobur", 21, []int{70, 80, 75}},
    }

    for _, t := range guruh {
        fmt.Println(t.Taqdim())
    }
}
Natija
Ali Karimov (20 yosh) — o'rtacha: 86.3 Zulfiya (19 yosh) — o'rtacha: 87.5 Bobur (21 yosh) — o'rtacha: 75.0
Go'da meros (inheritance) yo'q, lekin composition (bir structni boshqasiga joylash) orqali xuddi shu natijaga erishiladi. Bu Go falsafasining asosi!
Dars 12

Goroutine va Channel

Go'ning eng kuchli tomoni — concurrency! Goroutine'lar bir vaqtda minglab vazifalarni bajarishga imkon beradi.

goroutine.go
package main

import (
    "fmt"
    "sync"
    "time"
)

func vazifa(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Vazifa %d boshlandi\n", id)
    time.Sleep(100 * time.Millisecond)
    fmt.Printf("Vazifa %d tugadi\n", id)
}

func main() {
    // ═══ GOROUTINE ═══
    var wg sync.WaitGroup

    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go vazifa(i, &wg) // "go" bilan goroutine!
    }
    wg.Wait() // hammasi tugashini kutish

    // ═══ CHANNEL ═══
    ch := make(chan int)

    go func() {
        summa := 0
        for i := 1; i <= 100; i++ {
            summa += i
        }
        ch <- summa // channelga jo'natish
    }()

    natija := <-ch // channeldan olish
    fmt.Println("1 dan 100 gacha yig'indi:", natija)

    // ═══ BUFFERED CHANNEL ═══
    xabarlar := make(chan string, 2)
    xabarlar <- "birinchi"
    xabarlar <- "ikkinchi"

    fmt.Println(<-xabarlar)
    fmt.Println(<-xabarlar)

    // ═══ SELECT ═══
    c1 := make(chan string)
    c2 := make(chan string)

    go func() { c1 <- "c1 tayyor" }()
    go func() { c2 <- "c2 tayyor" }()

    for i := 0; i < 2; i++ {
        select {
        case msg := <-c1:
            fmt.Println(msg)
        case msg := <-c2:
            fmt.Println(msg)
        }
    }
}
Natija
Vazifa 1 boshlandi Vazifa 2 boshlandi Vazifa 3 boshlandi Vazifa 1 tugadi Vazifa 2 tugadi Vazifa 3 tugadi 1 dan 100 gacha yig'indi: 5050 birinchi ikkinchi c1 tayyor c2 tayyor

🚀 Goroutine

go func() yozish kifoya — thread dan yengilroq, minglab goroutine ishlaydi.

📡 Channel

Goroutine'lar orasida xavfsiz ma'lumot almashish uchun. make(chan int)

🔄 Select

Bir necha channelni kutish — qaysi biriga avval ma'lumot kelsa, o'sha ishlaydi.

🔒 WaitGroup

sync.WaitGroup — barcha goroutine'lar tugashini kutish uchun.

🎉
Tabriklaymiz!

Siz Go tilining barcha asosiy mavzularini o'zdingiz! Endi real loyihalar yarating: REST API, CLI dastur, yoki microservice.

go.dev/tour gobyexample.com pkg.go.dev