regexp

regexp — regulyar ifodalar (regular expressions) bilan ishlash uchun standart paket. Regulyar ifoda — bu matn ichidan ma'lum bir patternga (pattern) mos qismlarni topish, tekshirish yoki almashtirish uchun ishlatiladigan maxsus "so'rov tili".

Masalan: foydalanuvchi email manzili to'g'ri formatda kiritilganini tekshirish, matndan barcha telefon raqamlarini topish yoki matndagi barcha raqamlarni *** bilan almashtirish kabi vazifalarda regexp juda qo'l keladi.

import "regexp"

1. Regulyar ifodani tayyorlash: regexp.MustCompile()

Regulyar ifodadan foydalanishdan oldin, uni avval "kompilyatsiya" qilish kerak:

package main

import (
    "fmt"
    "regexp"
)

func main() {
    // \d+ — bitta yoki bir nechta ketma-ket raqamga mos keladi
    re := regexp.MustCompile(`\d+`)

    fmt.Println(re.MatchString("Salom123")) // matnda mos keluvchi qism bormi?
}

Natija:

true

[!IMPORTANT] MustCompile() va oddiy Compile() orasidagi farq: agar pattern noto'g'ri yozilgan bo'lsa, Compile() xatolikni oddiy error sifatida qaytaradi, MustCompile() esa dasturni darhol panic qilib to'xtatadi. Shu sababli MustCompile()ni faqat pattern dasturda qattiq yozilgan (hardcoded) va o'zgarmaydigan hollarda ishlating (bu eng ko'p uchraydigan holat). Agar pattern foydalanuvchidan yoki tashqi manbadan kelayotgan bo'lsa, Compile() va uning xatoligini tekshirish xavfsizroq.

2. Mos keluvchi qismni topish: FindString() va FindAllString()

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile(`\d+`)

    text := "Men 25 yoshdaman, uyimda 3 kishi"

    // BIRINCHI mos kelgan qismni topadi
    fmt.Println(re.FindString(text))

    // BARCHA mos kelgan qismlarni topadi (-1 — "cheklovsiz")
    fmt.Println(re.FindAllString(text, -1))
}

Natija:

25
[25 3]

3. Mos keluvchi qismlarni almashtirish: ReplaceAllString()

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile(`\d+`)

    replaced := re.ReplaceAllString("telefon: 998901234567", "***")

    fmt.Println(replaced)
}

Natija:

telefon: ***

Bu, masalan, log fayllarida yoki chiqishlarda maxfiy ma'lumotlarni (telefon raqami, karta raqami) yashirish uchun juda foydali.

4. Email formatini tekshirish (amaliy misol)

package main

import (
    "fmt"
    "regexp"
)

func main() {
    // soddalashtirilgan email patterni (real loyihalarda ko'proq qatorlarni hisobga olish kerak)
    emailRe := regexp.MustCompile(`^[\w.]+@[\w]+\.[a-z]+$`)

    fmt.Println(emailRe.MatchString("ali@example.com"))
    fmt.Println(emailRe.MatchString("notatemail"))
}

Natija:

true
false

Pattern tuzilishi:

• ^ — satr boshidan boshlanishi shart
• [\w.]+ — bir yoki bir nechta harf/raqam/nuqta (email nomi qismi)
• @ — aynan "@" belgisi
• [\w]+ — domen nomi (masalan, example)
• \. — aynan nuqta belgisi (.ni oddiy nuqta emas, aniq belgi sifatida qidirish uchun \ bilan "escape" qilingan)
• [a-z]+ — domen kengaytmasi (masalan, com)
• $ — satr oxirida tugashi shart

5. Pattern bo'yicha bo'lish: Split()

package main

import (
    "fmt"
    "regexp"
)

func main() {
    // \s*,\s* — vergul atrofidagi ixtiyoriy bo'sh joylar bilan birga
    splitRe := regexp.MustCompile(`\s*,\s*`)

    fmt.Println(splitRe.Split("olma, uzum ,anor", -1))
}

Natija:

[olma uzum anor]

strings.Split()dan farqli o'laroq, bu yerda ajratuvchi qat'iy bir belgi emas, balki pattern (bo'sh joylari turlicha bo'lishi mumkin) bo'yicha bo'linadi.

6. Pattern ichidagi guruhlarni ajratib olish: FindStringSubmatch()

Qavslar () orqali pattern ichida "guruhlar" belgilash mumkin — bu ularning har birini alohida ajratib olish imkonini beradi:

package main

import (
    "fmt"
    "regexp"
)

func main() {
    // uchta guruh: yil, oy, kun
    groupRe := regexp.MustCompile(`(\d{4})-(\d{2})-(\d{2})`)

    matches := groupRe.FindStringSubmatch("Sana: 2025-09-24")

    fmt.Println(matches)
    // matches[0] — to'liq mos kelgan qism, matches[1..] — har bir guruh
}

Natija:

[2025-09-24 2025 09 24]

matches[0] — butun sana (2025-09-24), matches[1] — yil (2025), matches[2] — oy (09), matches[3] — kun (24).

Xulosa: qachon qaysi funksiya kerak?

[!NOTE] Regulyar ifodalar juda kuchli, lekin ular ko'pincha yozish va o'qishda qiyin bo'ladi. Oddiy vazifalar uchun (masalan, satr boshlanishini tekshirish) avval strings paketidagi oddiyroq funksiyalarni (HasPrefix, Contains) ko'rib chiqing — regexpni faqat haqiqatan ham murakkab patternlar kerak bo'lganda ishlating.