String (matn)lar bilan ishlash

Ma'lumotlar turlari mavzusida string toifasi haqida aytib o'tgan edik, bu qismda shu mavzuga chuqurroq kiramiz.

Matnli (string) toifasi "" yoki '' belgilari bilan e'lon qilinadi.

String haqida umumiy nazariy ma'lumot

String toifasi dasturlashda eng keng tarqalgan ma'lumot turi bo'lib, u harflar, sonlar, belgilar va hatto bo'sh joylar ketma-ketligini ifodalaydi. Deyarli barcha dasturlash tillarida matnlar bilan ishlash uchun string toifasi mavjud. Quyida stringlar haqida asosiy nazariy ma'lumotlar keltiriladi:

1. O'zgaruvchanlik: Golangda string toifasi o'zgarmas (immutable) hisoblanadi, ya'ni bir marta yaratilgan stringni o'zgartirib bo'lmaydi. Har qanday o'zgartirish yangi string yaratadi.

2. Kodlash: Golang stringlari UTF-8 kodlash tizimidan foydalanadi, bu esa stringlarni turli xil tillarda va belgilar to'plamida qulay ishlatish imkonini beradi.

3. Indeksatsiya: Stringdagi har bir belgi indeksga ega bo'lib, bu indeks orqali belgilarga murojaat qilish mumkin. Indekslar 0 dan boshlanadi.

4. Bo'sh string: Bo'sh string bu uzunligi 0 bo'lgan stringdir (""). Bu dasturda matn mavjud emasligini ifodalash uchun ishlatiladi.

5. Operatsiyalar: Stringlar ustida qo'shish, taqqoslash, substring olish, uzunligini aniqlash kabi turli xil operatsiyalarni bajarish mumkin.

6. Xotira ishlatilishi: Har bir string bytelar ketma-ketligidan iborat bo'lib, har bir belgi ma'lum miqdordagi xotiradan foydalanadi. UTF-8 kodlash tizimi tufayli ba'zi belgilar bir necha baytni egallashi mumkin.

string turini e'lon qilishga misol

package main

import "fmt"

func main() {
    // Matnni "" ichida e'lon qilish
    var matn1 string = "Bu stringning birinchi misoli."

    // Matnni '' ichida e'lon qilish
    matn2 := 'A' // faqat bitta belgi uchun ishlatiladi

    // Matnni chop etish
    fmt.Println(matn1)
    fmt.Println(matn2)
}

Matn ustida amallar

Golangda matn ustida turli xil amallar bajarish mumkin. Quyida bir nechta asosiy amallar bilan tanishamiz.

1. Uzunlikni aniqlash

len() funksiyasi yordamida matnning uzunligini aniqlash mumkin.

package main

import "fmt"

func main() {
    matn := "Salom, dunyo!"

    // Uzunlikni aniqlash
    uzunlik := len(matn)
    fmt.Println("Matn uzunligi:", uzunlik)
}

2. Matndan belgilarni olish

Matndan indeks bo'yicha belgini olish mumkin. Indeks 0 dan boshlanadi.

package main

import "fmt"

func main() {
    matn := "Golang"

    // Belgini olish
    birinchiBelgi := matn[0]
    fmt.Printf("Birinchi belgi: %c\n", birinchiBelgi)
}

3. Matnlarni qo'shish

+ operatori yordamida ikkita matnni birlashtirish mumkin.

package main

import "fmt"

func main() {
    matn1 := "Salom, "
    matn2 := "Dunyo!"

    // Matnlarni qo'shish
    birlashtirilgan := matn1 + matn2
    fmt.Println(birlashtirilgan)
}

4. Matnlarni taqqoslash

Matnlarni taqqoslash uchun == va != operatorlaridan foydalaniladi.

package main

import "fmt"

func main() {
    matn1 := "Golang"
    matn2 := "Python"

    // Taqqoslash
    fmt.Println(matn1 == matn2) // false
    fmt.Println(matn1 != matn2) // true
}

5. Qism matn olish (substring)

Golangda qism matn olish uchun slice ([]) operatoridan foydalaniladi.

package main

import "fmt"

func main() {
    matn := "Salom, Dunyo!"

    // Qism matn olish
    qism := matn[7:12] // "Dunyo"
    fmt.Println(qism)
}

Golang String Functions

1. len – String uzunligini olish

   package main
   
   import (
       "fmt"
   )
   
   func main() {
       str := "Hello, Go!"
       fmt.Println(len(str)) // 11
   }
   

1. strings.Contains – Stringda substring mavjudligini tekshirish

   package main
   
   import (
       "fmt"
       "strings"
   )
   
   func main() {
       str := "Go programming language"
       fmt.Println(strings.Contains(str, "Go")) // true
       fmt.Println(strings.Contains(str, "Python")) // false
   }
   

1. strings.Count – Stringda substring qanchalik ko'p uchrashishini hisoblash

   package main
   
   import (
       "fmt"
       "strings"
   )
   
   func main() {
       str := "Go is Go"
       fmt.Println(strings.Count(str, "Go")) // 2
   }
   

1. strings.HasPrefix – Stringning boshida substring borligini tekshirish

   package main
   
   import (
       "fmt"
       "strings"
   )
   
   func main() {
       str := "Hello, Go!"
       fmt.Println(strings.HasPrefix(str, "Hello")) // true
       fmt.Println(strings.HasPrefix(str, "Go")) // false
   }
   

1. strings.HasSuffix – Stringning oxirida substring borligini tekshirish

   package main
   
   import (
       "fmt"
       "strings"
   )
   
   func main() {
       str := "Hello, Go!"
       fmt.Println(strings.HasSuffix(str, "Go!")) // true
       fmt.Println(strings.HasSuffix(str, "Go")) // false
   }
   

1. strings.Index – Substringning birinchi uchrashuvining indeksini topish

   package main
   
   import (
       "fmt"
       "strings"
   )
   
   func main() {
       str := "Hello, Go!"
       fmt.Println(strings.Index(str, "Go")) // 7
       fmt.Println(strings.Index(str, "Python")) // -1
   }
   

1. strings.Join – Stringlarni birlashtirish

   package main
   
   import (
       "fmt"
       "strings"
   )
   
   func main() {
       strs := []string{"Go", "is", "awesome"}
       fmt.Println(strings.Join(strs, " ")) // "Go is awesome"
   }
   

1. strings.Replace – Stringdagi substringni almashtirish

   package main
   
   import (
       "fmt"
       "strings"
   )
   
   func main() {
       str := "I like Go"
       updatedStr := strings.Replace(str, "Go", "Golang", 1)
       fmt.Println(updatedStr) // "I like Golang"
   }
   

1. strings.Split – Stringni substringlarga ajratish

   package main
   
   import (
       "fmt"
       "strings"
   )
   
   func main() {
       str := "apple,banana,cherry"
       words := strings.Split(str, ",")
       fmt.Println(words) // ["apple", "banana", "cherry"]
   }
   

1. strings.ToLower – Stringni kichik harflarga aylantirish

   package main
   
   import (
       "fmt"
       "strings"
   )
   
   func main() {
       str := "Go Programming Language"
       fmt.Println(strings.ToLower(str)) // "go programming language"
   }
   

1. strings.ToUpper – Stringni katta harflarga aylantirish

   package main
   
   import (
       "fmt"
       "strings"
   )
   
   func main() {
       str := "Go Programming Language"
       fmt.Println(strings.ToUpper(str)) // "GO PROGRAMMING LANGUAGE"
   }
   

1. strings.Trim – Stringning bosh va oxiridan bo'sh joylarni olib tashlash

   package main
   
   import (
       "fmt"
       "strings"
   )
   
   func main() {
       str := "   Go programming language   "
       fmt.Println(strings.Trim(str, " ")) // "Go programming language"
   }
   

1. strings.TrimSpace – Stringning bosh va oxiridan bo'sh joylarni olib tashlash (faqat bo'sh joylar)

   package main
   
   import (
       "fmt"
       "strings"
   )
   
   func main() {
       str := "   Go programming language   "
       fmt.Println(strings.TrimSpace(str)) // "Go programming language"
   }
   

1. strings.TrimPrefix – Stringning boshidan prefixni olib tashlash

   package main
   
   import (
       "fmt"
       "strings"
   )
   
   func main() {
       str := "Hello, Go!"
       fmt.Println(strings.TrimPrefix(str, "Hello")) // ", Go!"
   }
   

1. strings.TrimSuffix – Stringning oxiridan suffixni olib tashlash

   package main
   
   import (
       "fmt"
       "strings"
   )
   
   func main() {
       str := "Hello, Go!"
       fmt.Println(strings.TrimSuffix(str, "Go!")) // "Hello, "
   }
   

1. strings.Repeat – Stringni bir necha marta takrorlash

   package main
   
   import (
       "fmt"
       "strings"
   )
   
   func main() {
       str := "Go! "
       fmt.Println(strings.Repeat(str, 3)) // "Go! Go! Go! "
   }
   

1. strings.Fields – Stringni bo'sh joylarga qarab ajratish

   package main
   
   import (
       "fmt"
       "strings"
   )
   
   func main() {
       str := "Go is an open-source programming language"
       words := strings.Fields(str)
       fmt.Println(words) // ["Go", "is", "an", "open-source", "programming", "language"]
   }
   

1. strings.Map – Stringga funktsiyani qo'llash

   package main
   
   import (
       "fmt"
       "strings"
   )
   
   func main() {
       str := "Go"
       fmt.Println(strings.Map(func(r rune) rune {
           return r + 1
       }, str)) // "Hp"
   }
   

1. strings.ToTitle – Stringni bosh harflar bilan aylantirish

   package main
   
   import (
       "fmt"
       "strings"
   )
   
   func main() {
       str := "go programming"
       fmt.Println(strings.ToTitle(str)) // "Go Programming"
   }
   

1. strings.ContainsAny – Stringda berilgan harflardan biri mavjudligini tekshirish

   package main
   
   import (
       "fmt"
       "strings"
   )
   
   func main() {
       str := "Go programming language"
       fmt.Println(strings.ContainsAny(str, "abc")) // false
       fmt.Println(strings.ContainsAny(str, "op")) // true
   }