2. 程式人生 > >golang 正則匹配regexp介面實戰學習

golang 正則匹配regexp介面實戰學習

阿新 • • 發佈：2019-02-19

總覽

如果不熟悉正則表示式的語法的話，可以執行下面命令：

go doc regexp/syntax

聯絡程式碼

package main

import (
    "fmt"
    "regexp"
)

func expandTest() {
    pat := `(((abc.)def.)ghi)`
    reg := regexp.MustCompile(pat)
    fmt.Println(reg.NumSubexp())

    src := []byte(`abc-def-ghi abc+def+ghi`)
    template := []byte(`$0
 
   $1   $2   $3`)

    // 替換第一次匹配結果
    match := reg.FindSubmatchIndex(src)
    fmt.Printf("%v\n", match) // [0 11 0 11 0 8 0 4]
    dst := reg.Expand(nil, template, src, match)
    fmt.Printf("%s\n\n", dst)
    // abc-def-ghi   abc-def-ghi   abc-def-   abc-

    // 替換所有匹配結果
    for _, match := range reg.FindAllSubmatchIndex
 
(src, -1) {
        fmt.Printf("%v\n", match)
        dst := reg.Expand(nil, template, src, match)
        fmt.Printf("%s\n", dst)
    }
    // [0 11 0 11 0 8 0 4]
    // abc-def-ghi   abc-def-ghi   abc-def-   abc-
    // [12 23 12 23 12 20 12 16]
    // abc+def+ghi   abc+def+ghi   abc+def+   abc+
}

func testFind() {
    re := regexp.MustCompile
 
("a*r")
    fmt.Println(string(re.Find([]byte("paranoabrmal"))))
    fmt.Println(re.NumSubexp())

    rep := regexp.MustCompilePOSIX("a*r|ara")
    fmt.Println(string(rep.Find([]byte("paranoabrmal"))))
    fmt.Println(rep.NumSubexp())

    b := []byte("abc1def1")
    pat := `abc1|abc1def1`
    reg1 := regexp.MustCompile(pat)      // 第一匹配
    reg2 := regexp.MustCompilePOSIX(pat) // 最長匹配
    fmt.Printf("%s\n", reg1.Find(b))     // abc1
    fmt.Printf("%s\n", reg2.Find(b))     // abc1def1
    fmt.Println(reg1.NumSubexp())

    b = []byte("abc1def1")
    pat = `(abc|abc1def)*1`
    reg1 = regexp.MustCompile(pat)      // 第一匹配
    reg2 = regexp.MustCompilePOSIX(pat) // 最長匹配
    fmt.Printf("%s\n", reg1.Find(b))    // abc1
    fmt.Printf("%s\n", reg2.Find(b))    // abc1def1
    fmt.Println(reg1.NumSubexp())
}

func testFindAll() {
    re := regexp.MustCompile("ar")
    fmt.Printf("%q\n", (re.FindAll([]byte("paranoarmal"), -1)))

    rep := regexp.MustCompilePOSIX("ar")
    fmt.Printf("%q\n", (rep.FindAll([]byte("paranoarmal"), -1)))

    pat := `(((abc.)def.)ghi)`
    src := []byte(`abc-def-ghi abc+def+ghi`)

    reg := regexp.MustCompile(pat)
    fmt.Printf("%q\n", (reg.Find(src)))
    fmt.Printf("%q\n", (reg.FindAll(src, -1)))
    regp := regexp.MustCompilePOSIX(pat)
    fmt.Printf("%q\n", (regp.Find(src)))
    fmt.Printf("%q\n", (regp.FindAll(src, -1)))

}

func testReg(pat, srcStr string) {

    fmt.Println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
    src := []byte(srcStr)

    reg := regexp.MustCompile(pat)
    fmt.Printf("%q\n", (reg.Find(src)))
    fmt.Printf("%q\n", (reg.FindString(srcStr)))

    fmt.Printf("%q\n", (reg.FindAll(src, -1)))
    fmt.Printf("%q\n", (reg.FindAllString(srcStr, -1)))

    fmt.Printf("%d\n", (reg.FindIndex(src)))
    fmt.Printf("%d\n", (reg.FindStringIndex(srcStr)))

    fmt.Printf("%d\n", (reg.FindAllIndex(src, -1)))
    fmt.Printf("%d\n", (reg.FindAllStringIndex(srcStr, -1)))

    fmt.Println("begin submatch")
    fmt.Printf("%q\n", (reg.FindSubmatch(src)))
    fmt.Printf("%q\n", (reg.FindStringSubmatch(srcStr)))

    fmt.Printf("%d\n", (reg.FindSubmatchIndex(src)))
    fmt.Printf("%d\n", (reg.FindStringSubmatchIndex(srcStr)))

    fmt.Printf("%q\n", (reg.FindAllSubmatch(src, -1)))
    fmt.Printf("%q\n", (reg.FindAllStringSubmatch(srcStr, -1)))

    fmt.Printf("%d\n", (reg.FindAllSubmatchIndex(src, -1)))
    fmt.Printf("%d\n", (reg.FindAllStringSubmatchIndex(srcStr, -1)))

    regp := regexp.MustCompilePOSIX(pat)
    fmt.Printf("%q\n", (regp.Find(src)))
    fmt.Printf("%q\n", (regp.FindString(srcStr)))

    fmt.Printf("%q\n", (regp.FindAll(src, -1)))
    fmt.Printf("%q\n", (regp.FindAllString(srcStr, -1)))

    fmt.Printf("%d\n", (regp.FindIndex(src)))
    fmt.Printf("%d\n", (regp.FindStringIndex(srcStr)))

    fmt.Printf("%d\n", (regp.FindAllIndex(src, -1)))
    fmt.Printf("%d\n", (regp.FindAllStringIndex(srcStr, -1)))

    fmt.Println("begin submatch")
    fmt.Printf("%q\n", (regp.FindSubmatch(src)))
    fmt.Printf("%q\n", (regp.FindStringSubmatch(srcStr)))

    fmt.Printf("%q\n", (regp.FindAllSubmatch(src, -1)))
    fmt.Printf("%q\n", (regp.FindAllStringSubmatch(srcStr, -1)))

    fmt.Printf("%d\n", (regp.FindSubmatchIndex(src)))
    fmt.Printf("%d\n", (regp.FindStringSubmatchIndex(srcStr)))

    fmt.Printf("%d\n", (regp.FindAllSubmatchIndex(src, -1)))
    fmt.Printf("%d\n", (regp.FindAllStringSubmatchIndex(srcStr, -1)))

}

func main() {

    testReg(`(((abc.)def.)ghi)x*`, `abc-def-ghixxa abc+def+ghixx`)
    testReg(`(((abc.)def.)ghi)`, `abc-def-ghixxa abc+def+ghixx`)
    testReg(`a(x*)b(y|z)c`, `-axxxbyc- -abzc-`)
    testReg(`a*r`, `paranoabrmal`)

}

程式碼詳解

Find FindString

fmt.Printf("%q\n", (reg.Find(src)))
fmt.Printf("%q\n", (reg.FindString(srcStr)))

Find返回leftmost的正則匹配結果，也就是滿足匹配的最左邊的最短匹配字串

testReg(`(((abc.)def.)ghi)x*`, `abc-def-ghixxa abc+def+ghixx`)
結果："abc-def-ghixx"
分析：*表示0或多個，優先選擇多個，所以優先匹配為"abc-def-ghixx"

testReg(`(((abc.)def.)ghi)`, `abc-def-ghixxa abc+def+ghixx`)
結果："abc-def-ghi"
分析：滿足匹配項的的最左的最短匹配就是"abc-def-ghi"

testReg(`a(x*)b(y|z)c`, `-axxxbyc- -abzc-`)
結果："axxxbyc"
分析：滿足匹配項的的最左的最短匹配就是"abc-def-ghi"

testReg(`a*r`, `paranoabrmal`)
結果："ar"
分析：滿足匹配項的的最左的最短匹配就是"ar"

FindAll FIndAllString

fmt.Printf("%q\n", (reg.FindAll(src, -1)))
fmt.Printf("%q\n", (reg.FindAllString(srcStr, -1)))

FindAll是Find的“ALL”版本，返回相鄰的非互相覆蓋的最短匹配項

testReg(`(((abc.)def.)ghi)x*`, `abc-def-ghixxa abc+def+ghixx`)
結果：["abc-def-ghixx" "abc+def+ghixx"]
分析：返回所有匹配項

testReg(`(((abc.)def.)ghi)`, `abc-def-ghixxa abc+def+ghixx`)
結果：["abc-def-ghi" "abc+def+ghi"]
分析：返回所有匹配項

testReg(`a(x*)b(y|z)c`, `-axxxbyc- -abzc-`)
結果：["axxxbyc" "abzc"]
分析：返回所有匹配項

testReg(`a*r`, `paranoabrmal`)
結果：["ar" "r"]
分析：*表示0或多個，所以第二個就僅僅匹配了r

FindIndex FindStringIndex

fmt.Printf("%d\n", (reg.FindIndex(src)))
fmt.Printf("%d\n", (reg.FindStringIndex(srcStr)))

FindIndex是Find的“Index”版本，匹配項在原字串中的位置，返回nil標示沒有找到匹配項。

testReg(`(((abc.)def.)ghi)x*`, `abc-def-ghixxa abc+def+ghixx`)
結果：[0 13]
分析：`abc-def-ghixxa abc+def+ghixx`[0:13]就是"abc-def-ghixx"

testReg(`(((abc.)def.)ghi)`, `abc-def-ghixxa abc+def+ghixx`)
結果：[0 11]
分析：同上

testReg(`a(x*)b(y|z)c`, `-axxxbyc- -abzc-`)
結果：[1 8]
分析：同上

testReg(`a*r`, `paranoabrmal`)
結果：[1 3]
分析：同上

FindAllIndex FindAllStringIndex

fmt.Printf("%d\n", (reg.FindAllIndex(src, -1)))
fmt.Printf("%d\n", (reg.FindAllStringIndex(srcStr, -1)))

FindAllIndex是FindAll的“Index”版本，標示匹配項在原字串中的位置，返回nil標示沒有找到匹配項。

testReg(`(((abc.)def.)ghi)x*`, `abc-def-ghixxa abc+def+ghixx`)
結果：[[0 13] [15 28]]
分析：`abc-def-ghixxa abc+def+ghixx`[0:13]就是"abc-def-ghixx"
        `abc-def-ghixxa abc+def+ghixx`[15:28]就是"abc+def+ghixx"

testReg(`(((abc.)def.)ghi)`, `abc-def-ghixxa abc+def+ghixx`)
結果：[[0 11] [15 26]]
分析：同上

testReg(`a(x*)b(y|z)c`, `-axxxbyc- -abzc-`)
結果：[[1 8] [11 15]]
分析：同上

testReg(`a*r`, `paranoabrmal`)
結果：[[1 3] [8 9]]
分析：同上

FindSubmatch FindStringSubmatch

fmt.Printf("%q\n", (reg.FindSubmatch(src)))
fmt.Printf("%q\n", (reg.FindStringSubmatch(srcStr)))

FindSubmatch是Find的“Submatch”版本，這個版本返回正則表示式的子匹配項。子匹配指的是在括號內的子正則表示式，從左到右進行標號。
子匹配0標示全部的表示式，子匹配1標示第1個括號內的子表示式，以此類推。

testReg(`(((abc.)def.)ghi)x*`, `abc-def-ghixxa abc+def+ghixx`)
結果：["abc-def-ghixx" "abc-def-ghi" "abc-def-" "abc-"]
分析：“.”匹配任意字元。submatch0為 `(((abc.)def.)ghi)x*`,submatch1為`(((abc.)def.)ghi)`，submatch2為`((abc.)def.)`，submatch3為`(abc.)`，

testReg(`(((abc.)def.)ghi)`, `abc-def-ghixxa abc+def+ghixx`)
結果：["abc-def-ghi" "abc-def-ghi" "abc-def-" "abc-"]
分析：“.”匹配任意字元。submatch0為 `(((abc.)def.)ghi)`,submatch1為`(((abc.)def.)ghi)`，submatch2為`((abc.)def.)`，submatch3為`(abc.)`，

testReg(`a(x*)b(y|z)c`, `-axxxbyc- -abzc-`)
結果：["axxxbyc" "xxx" "y"]
分析：submatch0為`a(x*)b(y|z)c`，submatch1為`(x*)`，submatch2為`(y|z)`

testReg(`a*r`, `paranoabrmal`)
結果：["ar"]
分析：submatch0為`a*r`

FindSubmatchIndex FindStringSubmatchIndex

fmt.Printf("%d\n", (reg.FindSubmatchIndex(src)))
fmt.Printf("%d\n", (reg.FindStringSubmatchIndex(srcStr)))

FindSubmatchIndex是FindSubmatch的Index版本，返回匹配項的首尾下標

testReg(`(((abc.)def.)ghi)x*`, `abc-def-ghixxa abc+def+ghixx`)
結果：[0 13 0 11 0 8 0 4]
分析： `abc-def-ghixxa abc+def+ghixx`[0:13]="abc-def-ghixx"
        `abc-def-ghixxa abc+def+ghixx`[0:11]="abc-def-ghi"
        `abc-def-ghixxa abc+def+ghixx`[0:8]= "abc-def-"
        `abc-def-ghixxa abc+def+ghixx`[0:4]="abc-"

testReg(`(((abc.)def.)ghi)`, `abc-def-ghixxa abc+def+ghixx`)
結果：[0 11 0 11 0 8 0 4]
分析：同上

testReg(`a(x*)b(y|z)c`, `-axxxbyc- -abzc-`)
結果：[1 8 2 5 6 7]
分析：同上

testReg(`a*r`, `paranoabrmal`)
結果：[1 3]
分析：同上

FindAllSubmatch FindAllStringSubmatch

fmt.Printf("%q\n", (reg.FindAllSubmatch(src, -1)))
fmt.Printf("%q\n", (reg.FindAllStringSubmatch(srcStr, -1)))

FindAllSubmatch是FindSubmatch的“All”版本，這個版本返回全部匹配項的子匹配項。
子匹配0標示全部的表示式，子匹配1標示第1個括號內的子表示式，以此類推。

testReg(`(((abc.)def.)ghi)x*`, `abc-def-ghixxa abc+def+ghixx`)
結果：[["abc-def-ghixx" "abc-def-ghi" "abc-def-" "abc-"] ["abc+def+ghixx" "abc+def+ghi" "abc+def+" "abc+"]]
分析：參考FindSubmatch

testReg(`(((abc.)def.)ghi)`, `abc-def-ghixxa abc+def+ghixx`)
結果：[["abc-def-ghi" "abc-def-ghi" "abc-def-" "abc-"] ["abc+def+ghi" "abc+def+ghi" "abc+def+" "abc+"]]
分析：參考FindSubmatch


testReg(`a(x*)b(y|z)c`, `-axxxbyc- -abzc-`)
結果：[["axxxbyc" "xxx" "y"] ["abzc" "" "z"]]
分析：參考FindSubmatch


testReg(`a*r`, `paranoabrmal`)
結果：[["ar"] ["r"]]
分析：參考FindSubmatch

FindAllSubmatchIndex FindAllStringSubmatchIndex

fmt.Printf("%d\n", (reg.FindAllSubmatchIndex(src, -1)))
fmt.Printf("%d\n", (reg.FindAllStringSubmatchIndex(srcStr, -1)))

FindAllSubmatchIndex是FindAllSubmatch的Index版本，返回匹配項的首尾下標

testReg(`(((abc.)def.)ghi)x*`, `abc-def-ghixxa abc+def+ghixx`)
結果：[[0 13 0 11 0 8 0 4] [15 28 15 26 15 23 15 19]]
分析： 參考FindSubmatchIndex

testReg(`(((abc.)def.)ghi)`, `abc-def-ghixxa abc+def+ghixx`)
結果：[[0 11 0 11 0 8 0 4] [15 26 15 26 15 23 15 19]]
分析： 參考FindSubmatchIndex

testReg(`a(x*)b(y|z)c`, `-axxxbyc- -abzc-`)
結果：[[1 8 2 5 6 7] [11 15 12 12 13 14]]
分析： 參考FindSubmatchIndex

testReg(`a*r`, `paranoabrmal`)
結果：[[1 3] [8 9]]
分析： 參考FindSubmatchIndex

測試程式碼參考了這篇文章

相關推薦

golang 正則匹配regexp介面實戰學習

總覽 如果不熟悉正則表示式的語法的話，可以執行下面命令： go doc regexp/syntax 聯絡程式碼 package main import ( "fmt" "regexp" ) func expandTest(

golang 正則表示式 regexp

Golang中的正則表示式 ------------------------------------------------------------ 用法： ------------------------------ 單一：     .        匹配任意一個字元

正則匹配與替換 regexp & regsub

正則表達式 文本 兩種 抓取 有效 腳本編寫 多次 app ont 正則匹配是使用正則表達式匹配字符串的一種方法；在腳本編寫過程中，經常需要處理一些文本，而這些文本中可能只有部分信息是有用的，我們需要從文本中提取出這些有用信息；這時候，就需要編寫特定的正則表達式，將文本中符

正則匹配學習練習

aid 練習 驗證 pri 手機 數字 tex text group 　　　　一、驗證手機號碼： 　　　　text = ‘18578900345‘ 　　　　ret = re.match(‘1[34578]\d(9)‘,text) 　　　　print(ret.group())

【python學習筆記】44：Series.apply()列資料批量處理,Series.str.extract()正則匹配

學習《Python3爬蟲、資料清洗與視覺化實戰》時自己的一些實踐。 Series.apply()列資料批量處理 先將該列取出，形成Series物件，再呼叫apply()方法傳入用於處理的函式，這個過程就像map()一樣。 import pandas as pd # 各

MySql FIND_IN_SET, SUBSTRING_INDEX, REGEXP正則匹配等字串函式應用

Mysql資料庫提供了比較豐富的字串函式，如上文“談談Mysql 字串連線 CONCAT CONCAT_WS GROUP_CONCAT區別及使用場景”中提到的字串連線函式，本文繼續講述Mysql剩餘常用字串函式的使用注意事項及使用場景。 1、字串長度 CHAR_LENGTH(

Jmeter介面測試（六）關聯&正則匹配

問題思考 　　介面測試過程中經常需要介面之間關聯呼叫，比如獲取上一個介面的返回值，作為另一個介面的請求引數，那麼該如何從處理呢？ 　　這裡需要使用 Jmeter 的正則表示式提取器，通過對響應的資料來提取指定的資料。 操作案例 　　從請求 get請求 的響應資

python中正則匹配字符配置單詞邊界不生效的解決辦法

re python duoceshi #-*-coding:utf-8-*-import rename="duoceshi"p= re.compile(‘\bduoceshi\b‘)f = p.search(name)if f: print f.group()################

正則匹配 替換..追加..

bbs csdn 正則 flow code pan net eval nbsp 這裏都是以 圖片中的元素為例： 匹配出IMG標簽中alt的值: 1 Regex reg = new Regex(@"(?is)(?<=<img[^>]*)[^""]*(?

day11 grep正則匹配

collect lec linux 取反 pat 至少 判斷 con set ps aus | trep nginx # 查看所有正在運行的nginx任務 別名路徑： alias test_cmd=‘ls -l‘ PATH路徑： 臨時修改：

常用的正則匹配

marked clas 字符串 輸入 har round back [0 num 1.判斷只能輸入數字和字母 var num_char = /^[0-9A-Za-z]+$/; 　　^ :代表匹配字符串開始位置; 　　[0-9A-Za-z]+ :[0-9A-Za-z]匹配數

js 對表單的一些驗證及正則匹配

攻擊 update 匹配規則 asc htm out gin lease public 利用的是jq的validate.js 詳見菜鳥教程http://www.runoob.com/jquery/jquery-plugin-validate.html 以下是我測試的幾個文件

正則匹配所有的a標簽

結束 strong 分組 正則匹配 ref val 所有 a標簽 解釋 <a\b[^>]+\bhref="([^"]*)"[^>]*>([\s\S]*?)</a> 分組1和分組2即為href和value 解釋： <a\b

關於JAVA正則匹配空白字符的問題(全角空格與半角空格)

轉義 空白 測試 rgs com text color 如何 clas 今天遇到一個字符串，怎麽匹配空格都不成功！！！ 我把空格復制到test.properties文件 顯示“\u3000” ，這是什麽？ 這是全角空格！！！ 查了一下 \s

PHP正則表達式的快速學習方法

rep 邊界 web頁面 匹配 too 引用 span 常用 正常 2008-10-20 22:08 1、入門簡介 簡單的說，正則表達式是一種可以用於模式匹配和替換的強有力的工具。我們可以在幾乎所有的基於UNIX系統的工具中找到正則表達式的身影，例如，vi

正則匹配<img>

普通 空白字符 展開 反向引用 功能 php php應用 換行 一個 preg_match_all(‘/<img(.*?)src=\"(.*?)\"(.*?)>/is‘, $content, $matches); matches[0] 整個img標簽 match

js正則匹配的出鏈接地址

鏈接地址 匹配 ase lower length ont 正則匹配 nbsp case content為需要匹配的值 var b=/<a([\s]+|[\s]+[^<>]+[\s]+)href=(\"([^<>"\‘]*)\"|\‘([^

awk結合正則匹配

需要 上海 所有 統計 技術 領域 panda -1 數據處理 利用awk分析data.csv中label列各取值的分布． 在終端執行head data.csv查看數據： 1 name,business,label,label_name 2 滄州光松房屋拆遷有限公

正則匹配方法

blank csdn 關於 expr 取ip地址 數值 換ip 表達式 java 這裏是幾個主要非英文語系字符範圍(google上找到的): 2E80～33FFh：中日韓符號區。收容康熙字典部首、中日韓輔助部首、註音符號、日本假名、韓文音符，中日韓的符號、標點、帶圈或帶括

修正正則匹配日期---基於網絡未知大神的正則

http 日期 bsp question ges 基於 就會 貢獻 工作 今天工作時需要用到日期格式檢驗，於是發現未知的大神貢獻的一套正則表達式【1】，看起來很復雜； 但是經過測試發現有些問題： ((\d{2}(([02468][048])|([13579][26]