Go言語の正規表現一覧と基本構文について解説

package main
import (
	"fmt"
)
func main() {
	// メタ文字の一覧をスライスに格納
	metaCharacters := []string{".", "^", "$", "*", "+", "?", "{", "}", "[", "]", "(", ")", "|", "\\"}
	for _, char := range metaCharacters {
		fmt.Println("メタ文字:", char)
	}
}

メタ文字: .
メタ文字: ^
メタ文字: $
メタ文字: *
メタ文字: +
メタ文字: ?
メタ文字: {
メタ文字: }
メタ文字: [
メタ文字: ]
メタ文字: (
メタ文字: )
メタ文字: |
メタ文字: \

package main
import (
	"fmt"
	"regexp"
)
func main() {
	// エスケープが必要な文字列
	rawPattern := `a.b*c`
	// regexp.QuoteMetaでエスケープ済みのパターンを生成
	escapedPattern := regexp.QuoteMeta(rawPattern)
	fmt.Println("エスケープ前:", rawPattern)
	fmt.Println("エスケープ後:", escapedPattern)
}

エスケープ前: a.b*c
エスケープ後: a\.b\*c

package main
import (
	"fmt"
	"regexp"
)
func main() {
	// 英字のパターンを定義
	pattern := "[a-z]+"
	text := "abc XYZ"
	re, err := regexp.Compile(pattern)
	if err != nil {
		fmt.Println("エラー:", err)
		return
	}
	// 英字の小文字にマッチする部分を検索
	match := re.FindString(text)
	fmt.Println("マッチした文字列:", match)
}

マッチした文字列: abc

package main
import (
	"fmt"
	"regexp"
)
func main() {
	// 日付形式を検出する正規表現パターン
	pattern := `([0-9]{4})-([0-9]{2})-([0-9]{2})`
	text := "本日の日時は2023-10-15です。"
	re, err := regexp.Compile(pattern)
	if err != nil {
		fmt.Println("エラー:", err)
		return
	}
	// キャプチャを含むマッチを取得
	match := re.FindStringSubmatch(text)
	if len(match) > 0 {
		fmt.Println("全体:", match[0])
		fmt.Println("年:", match[1])
		fmt.Println("月:", match[2])
		fmt.Println("日:", match[3])
	} else {
		fmt.Println("マッチなし")
	}
}

全体: 2023-10-15
年: 2023
月: 10
日: 15

package main
import (
	"fmt"
	"regexp"
)
func main() {
	pattern := `^\d+(\.\d+)?$`
	re, err := regexp.Compile(pattern)
	if err != nil {
		fmt.Println("正規表現のコンパイルエラー:", err)
		return
	}
	testStrings := []string{"123", "45.67", "abc", "89.12.34"}
	for _, str := range testStrings {
		if re.MatchString(str) {
			fmt.Println(str, "は数値にマッチしました。")
		} else {
			fmt.Println(str, "は数値にマッチしません。")
		}
	}
}

123 は数値にマッチしました。
45.67 は数値にマッチしました。
abc は数値にマッチしません。
89.12.34 は数値にマッチしません。

package main
import (
	"fmt"
	"regexp"
)
func main() {
	pattern := `[a-zA-Z]+`
	re, err := regexp.Compile(pattern)
	if err != nil {
		fmt.Println("コンパイルエラー:", err)
		return
	}
	text := "Go言語123 and Python"
	matches := re.FindAllString(text, -1)
	fmt.Println("マッチした単語一覧:", matches)
}

マッチした単語一覧: [Go 言 語 and Python]

package main
import (
	"fmt"
	"regexp"
)
func main() {
	pattern := `^Hello.*World$`
	re, err := regexp.Compile(pattern)
	if err != nil {
		fmt.Println("パターンのコンパイルエラー:", err)
		return
	}
	testString := "Hello Go Language World"
	if re.MatchString(testString) {
		fmt.Println("文字列はパターンにマッチしています。")
	} else {
		fmt.Println("文字列はパターンにマッチしていません。")
	}
}

文字列はパターンにマッチしています。

package main
import (
	"fmt"
	"regexp"
)
func main() {
	// "go"が1回以上続くパターン
	patternPlus := `(go)+`
	rePlus, err := regexp.Compile(patternPlus)
	if err != nil {
		fmt.Println("コンパイルエラー:", err)
		return
	}
	textPlus := "gogogo!"
	matchPlus := rePlus.FindString(textPlus)
	fmt.Println("1回以上のマッチ:", matchPlus)
	// "go"が0回または1回出現するパターン
	patternOptional := `(go)?`
	reOptional, err := regexp.Compile(patternOptional)
	if err != nil {
		fmt.Println("コンパイルエラー:", err)
		return
	}
	textOptional := "abc"
	matchOptional := reOptional.FindString(textOptional)
	fmt.Println("オプショナルマッチ:", matchOptional)
}

1回以上のマッチ: gogogo
オプショナルマッチ:

package main
import (
	"fmt"
	"regexp"
)
func main() {
	pattern := `\d{3}`
	text := "受注番号は123456です。"
	// 文字列がパターンにマッチするかチェック
	match, err := regexp.MatchString(pattern, text)
	if err != nil {
		fmt.Println("エラー:", err)
		return
	}
	fmt.Println("パターンにマッチしているか:", match)
	// マッチした最初の文字列を取得するために、コンパイル済み正規表現を利用
	re, err := regexp.Compile(pattern)
	if err != nil {
		fmt.Println("コンパイルエラー:", err)
		return
	}
	found := re.FindString(text)
	fmt.Println("抽出された文字列:", found)
}

パターンにマッチしているか: true
抽出された文字列: 123

package main
import (
	"fmt"
	"regexp"
)
func main() {
	// メールアドレスのパターンを定義
	pattern := `@[\w.]+`
	re, err := regexp.Compile(pattern)
	if err != nil {
		fmt.Println("エラー:", err)
		return
	}
	originalEmail := "example@old-domain.com"
	// ドメイン部分を新しい文字列に置換
	newEmail := re.ReplaceAllString(originalEmail, "@new-domain.com")
	fmt.Println("元のメールアドレス:", originalEmail)
	fmt.Println("置換後のメールアドレス:", newEmail)
}

元のメールアドレス: example@old-domain.com
置換後のメールアドレス: example@new-domain.com

package main
import (
	"fmt"
	"regexp"
)
func main() {
	// 不正なパターンを意図的に使用
	pattern := `(\d+`
	re, err := regexp.Compile(pattern)
	if err != nil {
		fmt.Println("パターンのコンパイルに失敗しました:", err)
		return
	}
	// ここには到達しないが、正常ならば利用するコード
	fmt.Println("コンパイルしたパターン:", re.String())
}

パターンのコンパイルに失敗しました: error parsing regexp: missing closing ): `(\d+`

package main
import (
	"fmt"
	"regexp"
)
func main() {
	// コンパイル済みパターンを複数回利用する例
	// MustCompileはエラー発生時にpanicするため、確実なパターンで利用する
	re := regexp.MustCompile(`[A-Z][a-z]+`)
	text := "Go言語とPythonとJava"
	// パターンにマッチした部分を全て取得する
	matches := re.FindAllString(text, -1)
	fmt.Println("大文字で始まる単語:", matches)
}

大文字で始まる単語: [Go Python Java]