Pemprosesan rentetan dan ungkapan biasa dalam bahasa Go

Pemprosesan rentetan dan ungkapan biasa dalam bahasa Go

Bahasa Go ialah bahasa ditaip kuat, di mana rentetan ialah jenis data yang biasa digunakan. Dalam proses pembangunan program, pemprosesan rentetan adalah bahagian yang sangat penting. Artikel ini akan memperkenalkan operasi asas pemprosesan rentetan dan penggunaan ungkapan biasa dalam bahasa Go.

1. Pemprosesan rentetan

Jenis rentetan bahasa Go ialah urutan bait yang tidak boleh diubah, iaitu, setelah dibuat, nilainya tidak boleh diubah suai. Rentetan boleh diwakili menggunakan petikan berganda atau tanda belakang. Urutan melarikan diri boleh digunakan dalam rentetan petikan dua kali, seperti
untuk mewakili aksara baris baharu. Rentetan tanda belakang boleh mengandungi sebarang aksara, termasuk teks berbilang baris dan aksara melarikan diri.

1. String concatenation

Anda boleh menggunakan + operator dalam bahasa Go untuk menyambung dua rentetan, contohnya:

str1 := "Hello"
str2 := "world"
str3 := str1 + " " + str2
fmt.Println(str3) // output: Hello world

2. String splitting

Anda boleh menggunakan fungsi Split() dalam pakej rentetan untuk membelah rentetan . Contohnya:

str := "Hello world"
arr := strings.Split(str, " ")
fmt.Println(arr) // output: [Hello world]

3. Penggantian rentetan

Anda boleh menggunakan fungsi Ganti() dalam pakej rentetan untuk menggantikan rentetan. Contohnya:

str := "Hello world"
newStr := strings.Replace(str, "world", "Go", 1)
fmt.Println(newStr) // output: Hello Go

4. String lookup

Anda boleh menggunakan fungsi Index() atau Contains() dalam pakej rentetan untuk mencari rentetan. Contohnya:

str := "Hello world"
index := strings.Index(str, "world")
fmt.Println(index) // output: 6
isContains := strings.Contains(str, "Hello")
fmt.Println(isContains) // output: true

5. Penukaran kes rentetan

Anda boleh menggunakan fungsi ToUpper() dan ToLower() dalam pakej rentetan untuk menukar kes rentetan. Contohnya:

str := "Hello WORLD"
newStr1 := strings.ToUpper(str)
newStr2 := strings.ToLower(str)
fmt.Println(newStr1) // output: HELLO WORLD
fmt.Println(newStr2) // output: hello world

2. Ungkapan biasa

Ungkapan biasa ialah alat yang digunakan untuk menerangkan rentetan dan boleh menentukan sama ada rentetan sepadan dengan corak tertentu. Bahasa Go mempunyai pakej regexp terbina dalam yang boleh menggunakan ungkapan biasa untuk memadankan dan memanipulasi rentetan.

1. Karakter meta asas ungkapan biasa

• .: Memadankan mana-mana aksara
• d: Memadankan nombor, bersamaan dengan [0-9]
• D: Memadankan mana-mana aksara kecuali nombor, bersamaan dengan
w: Memadankan huruf dan nombor, bersamaan dengan [a-zA-Z0-9]
• W: Memadankan mana-mana aksara yang bukan huruf dan nombor, bersamaan dengan
• ²
s : Memadankan aksara ruang putih seperti ruang atau tab
• S: Padan dengan aksara bukan ruang putih
• ^: Padan dengan permulaan rentetan
• $: Padankan dengan penghujung rentetan
• []: Padankan mana-mana aksara dalam kurungan segi empat sama
[^]: Padankan mana-mana aksara kecuali aksara dalam kurungan segi empat sama

Fungsi ungkapan biasa

MatchString(rentetan corak, rentetan s) bool: Tentukan sama ada rentetan s sepadan dengan ekspresi biasa corak Rentetan corak
CariString(rentetan), rentetan: Cari subrentetan pertama yang sepadan dengan corak corak ungkapan biasa dalam rentetan s dan kembalikan subrentetan
• FindAllString(rentetan pola, rentetan s, n int ) []rentetan: Cari semua rentetan padanan corak corak ungkapan biasa dalam rentetan s dan kembalikan hirisan tali. n mewakili bilangan maksimum padanan
• ReplaceAllString(rentetan corak, rentetan s, rentetan repl) rentetan: Gunakan rentetan repl untuk menggantikan semua rentetan dalam rentetan s yang sepadan dengan corak corak ungkapan biasa dan kembalikan rentetan yang diganti

Contoh ungkapan biasa

3. package main
   
   import (
       "fmt"
       "regexp"
   )
   
   func main() {
       str1 := "abc123"
       str2 := "Hello world"
       pattern1 := `d+`
       pattern2 := `wo..d`
       isMatch1, _ := regexp.MatchString(pattern1, str1)
       isMatch2, _ := regexp.MatchString(pattern2, str2)
       fmt.Println(isMatch1) // output: true
       fmt.Println(isMatch2) // output: true
       
       re := regexp.MustCompile(pattern1)
       match1 := re.FindString(str1)
       fmt.Println(match1) // output: 123
       
       matchAll1 := re.FindAllString(str1, -1)
       fmt.Println(matchAll1) // output: [123]
       
       repl := re.ReplaceAllString(str1, "456")
       fmt.Println(repl) // output: abc456
       
       re2 := regexp.MustCompile(pattern2)
       match2 := re2.FindString(str2)
       fmt.Println(match2) // output: world
   }

Ringkasan

Artikel ini memperkenalkan penggunaan pemprosesan rentetan dan ungkapan biasa dalam bahasa Go. Pemprosesan rentetan termasuk operasi asas seperti penggabungan, pemisahan, penggantian, pencarian dan penukaran kes. Ungkapan biasa boleh digunakan untuk memadankan dan memanipulasi rentetan yang sepadan dengan corak tertentu. Menguasai operasi ini boleh memudahkan untuk memproses rentetan dan meningkatkan kecekapan pembangunan program.

---

0-9
1. ↩
a-zA-Z0-9
2. ↩

Atas ialah kandungan terperinci Pemprosesan rentetan dan ungkapan biasa dalam bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!