Petua ungkapan biasa bahasa Go: cara memadankan aksara berulang berturut-turut

Go Language Petua Ungkapan Biasa: Cara Memadankan Aksara Berulang Berterusan

Ekspresi biasa ialah alat yang berkuasa untuk memadankan dan memanipulasi rentetan. Dalam bahasa Go, terdapat sokongan terbina dalam untuk ungkapan biasa, yang melaluinya anda boleh memadankan, mencari dan menggantikan rentetan dengan mudah. Artikel ini akan memperkenalkan cara menggunakan ungkapan biasa untuk memadankan aksara berulang berturut-turut dalam bahasa Go.

Dalam ungkapan biasa, gunakan kelayakan ulangan untuk memadankan bilangan aksara berulang yang ditentukan. Kelayakan berulang yang biasa ialah: *, +, ?, {n}, {n ,} dan {n,m}. *、+、?、{n}、{n,}和{n,m}。

*用于匹配零个或多个重复字符，例如正则表达式ab*c可以匹配ac、abc、abbc等字符串。

+用于匹配一个或多个重复字符，例如正则表达式ab+c可以匹配abc、abbc、abbbc等字符串。

?用于匹配零个或一个重复字符，例如正则表达式ab?c可以匹配ac、abc等字符串。

{n}用于匹配恰好n个重复字符，例如正则表达式ab{2}c可以匹配abbc。

{n,}用于匹配至少n个重复字符，例如正则表达式ab{2,}c可以匹配abbc、abbbc、abbbbc等字符串。

{n,m}用于匹配至少n个且不超过m个重复字符，例如正则表达式ab{2,4}c可以匹配abbc、abbbc、abbbbc等字符串。

下面是一个示例程序，演示了如何使用正则表达式匹配连续重复的字符：

package main

import (
    "fmt"
    "regexp"
)

func main() {
    str := "aaa bbb cccc dddd"

    // 使用正则表达式匹配两个以上连续的a字符
    reg := regexp.MustCompile(`a{2,}`)
    result := reg.FindAllString(str, -1)
    fmt.Printf("连续的a字符: %v
", result)

    // 使用正则表达式匹配三个以上连续的b字符
    reg = regexp.MustCompile(`b{3,}`)
    result = reg.FindAllString(str, -1)
    fmt.Printf("连续的b字符: %v
", result)

    // 使用正则表达式匹配四个以上连续的c字符
    reg = regexp.MustCompile(`c{4,}`)
    result = reg.FindAllString(str, -1)
    fmt.Printf("连续的c字符: %v
", result)

    // 使用正则表达式匹配连续的d字符，不限数量
    reg = regexp.MustCompile(`d+`)
    result = reg.FindAllString(str, -1)
    fmt.Printf("连续的d字符: %v
", result)
}

运行上述示例程序，输出如下结果：

连续的a字符: [aaa]
连续的b字符: []
连续的c字符: [cccc]
连续的d字符: [dddd]

在示例程序中，我们首先定义了一个字符串str，其中包含了多个连续重复的字符。然后，我们使用正则表达式a{2,}来匹配两个以上连续的a字符，使用正则表达式b{3,}来匹配三个以上连续的b字符，使用正则表达式c{4,}来匹配四个以上连续的c字符，使用正则表达式d+来匹配连续的d字符（不限数量）。最后，我们使用FindAllString

* digunakan untuk memadankan sifar atau lebih aksara berulang Contohnya, ungkapan biasa ab*c boleh sepadan dengan ac, abc , abbc dan rentetan lain.

+ digunakan untuk memadankan satu atau lebih aksara berulang Contohnya, ungkapan biasa ab+c boleh memadankan abc, . abbc, <code>abbbc dan rentetan lain.

? digunakan untuk memadankan sifar atau satu aksara berulang Contohnya, ungkapan biasa ab?c boleh sepadan dengan ac, abc dan rentetan lain. 🎜🎜<kod>{n}</kod> digunakan untuk memadankan dengan tepat n aksara berulang Contohnya, ungkapan biasa ab{2}c boleh sepadan dengan abbc. 🎜🎜{n,} digunakan untuk memadankan sekurang-kurangnya n aksara berulang Contohnya, ungkapan biasa ab{2,}c boleh memadankan abbccode>, Rentetan seperti <code>abbbc, abbbbc. 🎜🎜{n,m} digunakan untuk memadankan sekurang-kurangnya n dan tidak lebih daripada m aksara berulang Contohnya, ungkapan biasa ab{2,4}c boleh padankan abbc, abbbc, abbbbc dan rentetan lain. 🎜🎜Berikut ialah contoh program yang menunjukkan cara menggunakan ungkapan biasa untuk memadankan aksara berulang berturut-turut: 🎜rrreee🎜Jalankan program sampel di atas dan keputusan berikut adalah output: 🎜rrreee🎜Dalam program sampel, kami mula-mula menentukan rentetan str, yang mengandungi berbilang aksara berulang berturut-turut. Kemudian, kami menggunakan ungkapan biasa a{2,} untuk memadankan lebih daripada dua aksara berturut-turut dan ungkapan biasa b{3,} untuk memadankan lebih daripada tiga Untuk aksara b berturut-turut, gunakan ungkapan biasa c{4,} untuk memadankan lebih daripada empat aksara c berturut-turut dan gunakan ungkapan biasa d+ untuk memadankan aksara d berturut-turut ( Tiada had pada kuantiti). Akhir sekali, kami menggunakan fungsi FindAllString untuk mencari semua subrentetan yang sepadan dengan ungkapan biasa daripada rentetan dan mencetak hasilnya. 🎜🎜Melalui contoh di atas, kita dapat melihat bahawa sangat mudah untuk menggunakan ungkapan biasa untuk memadankan aksara berulang berturut-turut dalam bahasa Go. Anda hanya perlu menentukan peraturan padanan dan kemudian menggunakan fungsi yang disediakan oleh perpustakaan ungkapan biasa untuk pemadanan. 🎜🎜Untuk meringkaskan, ungkapan biasa ialah alat berkuasa yang boleh membantu kami memadankan, mencari dan menggantikan kandungan yang diperlukan dalam rentetan. Dalam bahasa Go, anda boleh memanipulasi rentetan dengan mudah melalui pustaka ungkapan biasa. Untuk memadankan aksara berulang berturut-turut, anda hanya perlu menentukan peraturan padanan dan kemudian menggunakan fungsi yang disediakan oleh perpustakaan ungkapan biasa untuk dipadankan. Saya harap artikel ini akan membantu anda menggunakan ungkapan biasa untuk memadankan aksara berulang berturut-turut dalam bahasa Go. 🎜

Atas ialah kandungan terperinci Petua ungkapan biasa bahasa Go: cara memadankan aksara berulang berturut-turut. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!