Go言語の正規表現

## 基本的な使い方
Go言語のregexpパッケージを使用して、正規表現を扱う基本的な方法を以下に示します。
1. 正規表現のコンパイル
正規表現を使用する前に、まず正規表現パターンをコンパイルする必要があります。***regexp.Compile関数***を使用して正規表現パターンをコンパイルします。
```go:例
package main

import (
    "fmt"
    "regexp"
)

func main() {
    pattern := `[a-zA-Z]+`
    re, err := regexp.Compile(pattern)
    if err != nil {
        fmt.Println("Error compiling regex:", err)
        return
    }
    fmt.Println("Regex compiled successfully:", re)
}
```
```:結果
Regex compiled successfully: [a-zA-Z]+
```
2. パターンマッチング
コンパイルした正規表現を使用して、文字列がパターンに一致するかどうかを確認します。***MatchStringメソッド***を使用します。
```go:例
package main

import (
    "fmt"
    "regexp"
)

func main() {
    pattern := `[a-zA-Z]+`
    re, _ := regexp.Compile(pattern)
    text := "Hello123"
    match := re.MatchString(text)
    fmt.Println("Does the text match the pattern?", match)
}
```

```:結果
Does the text match the pattern? true
```
3. 一致する部分文字列の検索
正規表現パターンに一致する部分文字列を検索するには、***FindStringメソッド***を使用します。
```go:例
package main

import (
    "fmt"
    "regexp"
)

func main() {
    pattern := `[a-zA-Z]+`
    re, _ := regexp.Compile(pattern)
    text := "Hello123"
    match := re.FindString(text)
    fmt.Println("Matched substring:", match)
}
```
```:結果
Matched substring: Hello
```
4. 一致するすべての部分文字列の検索
正規表現パターンに一致するすべての部分文字列を検索するには、***FindAllStringメソッド***を使用します。
```go:例
package main

import (
    "fmt"
    "regexp"
)

func main() {
    pattern := `[a-zA-Z]+`
    re, _ := regexp.Compile(pattern)
    text := "Hello123 World456"
    matches := re.FindAllString(text, -1)
    fmt.Println("All matched substrings:", matches)
}
```
```:結果
All matched substrings: [Hello World]
```
5. 文字列の置換
正規表現パターンに一致する部分文字列を置換するには、***ReplaceAllStringメソッド***を使用します。
```go:例
package main

import (
    "fmt"
    "regexp"
)

func main() {
    pattern := `[a-zA-Z]+`
    re, _ := regexp.Compile(pattern)
    text := "Hello123 World456"
    replaced := re.ReplaceAllString(text, "Replaced")
    fmt.Println("Replaced text:", replaced)
}
```
```:結果
Replaced text: Replaced123 Replaced456
```
## 正規表現の特殊文字とシーケンス
Go言語の正規表現では、以下のような特殊文字とシーケンスを使用できます：
- .: 任意の1文字に一致
- ^: 行の先頭に一致
- $: 行の末尾に一致
- *: 0回以上の繰り返しに一致
- +: 1回以上の繰り返しに一致
- ?: 0回または1回の繰り返しに一致
- |: OR条件に一致
- []: 文字クラスに一致
- \d: 任意の数字に一致
- \w: 任意の単語文字（アルファベット、数字、アンダースコア）に一致
- \s: 任意の空白文字に一致
- \b: 単語の境界に一致

#### 例：任意の1文字に一致
```go:例
package main

import (
    "fmt"
    "regexp"
)

func main() {
    pattern := `a.b`
    re, _ := regexp.Compile(pattern)
    text := "a1b a2b a3b"
    matches := re.FindAllString(text, -1)
    fmt.Println("All matched substrings:", matches)
}
```
```:結果
All matched substrings: [a1b a2b a3b]
```
#### 例：行の先頭に一致
```go:例
package main

import (
    "fmt"
    "regexp"
)

func main() {
    pattern := `(?m)^Hello`
    re, _ := regexp.Compile(pattern)
    text := "Hello World\nHello Go"
    matches := re.FindAllString(text, -1)
    fmt.Println("All matched substrings:", matches)
}
```
```:結果
All matched substrings: [Hello Hello]
```
#### 例：行の末尾に一致
```go:例
package main

import (
    "fmt"
    "regexp"
)

func main() {
    pattern := `Go$`
    re, _ := regexp.Compile(pattern)
    text := "Hello World\nHello Go"
    matches := re.FindAllString(text, -1)
    fmt.Println("All matched substrings:", matches)
}
```
```:結果
All matched substrings: [Go]
```
#### 例：0回以上の繰り返しに一致
```go:例
package main

import (
    "fmt"
    "regexp"
)

func main() {
    pattern := `a*`
    re, _ := regexp.Compile(pattern)
    text := "aaa b aa c a"
    matches := re.FindAllString(text, -1)
    fmt.Println("All matched substrings:", matches)
}
```
```:結果
All matched substrings: [aaa  aa  a ]
```
#### 例：1回以上の繰り返しに一致
```go:例
package main

import (
    "fmt"
    "regexp"
)

func main() {
    pattern := `a+`
    re, _ := regexp.Compile(pattern)
    text := "aaa b aa c a"
    matches := re.FindAllString(text, -1)
    fmt.Println("All matched substrings:", matches)
}
```
```:結果
All matched substrings: [aaa aa a]
```
#### 例：0回または1回の繰り返しに一致
```go:例
package main

import (
    "fmt"
    "regexp"
)

func main() {
    pattern := `a?`
    re, _ := regexp.Compile(pattern)
    text := "aaa b aa c a"
    matches := re.FindAllString(text, -1)
    fmt.Println("All matched substrings:", matches)
}
```
```:結果
All matched substrings: [a a a   a a   a]
```
#### 例：OR条件に一致
```go:例
package main

import (
    "fmt"
    "regexp"
)

func main() {
    pattern := `a|b`
    re, _ := regexp.Compile(pattern)
    text := "a b c d e f g"
    matches := re.FindAllString(text, -1)
    fmt.Println("All matched substrings:", matches)
}
```
```:結果
All matched substrings: [a b]
```
#### 例：文字クラスに一致
```go:例
package main

import (
    "fmt"
    "regexp"
)

func main() {
    pattern := `[aeiou]`
    re, _ := regexp.Compile(pattern)
    text := "abcdefghijklmnopqrstuvwxyz"
    matches := re.FindAllString(text, -1)
    fmt.Println("All matched substrings:", matches)
}
```
```:結果
All matched substrings: [a e i o u]
```
#### 例：任意の数字に一致
```go:例
package main

import (
    "fmt"
    "regexp"
)

func main() {
    pattern := `\d`
    re, _ := regexp.Compile(pattern)
    text := "123 abc 456 def"
    matches := re.FindAllString(text, -1)
    fmt.Println("All matched substrings:", matches)
}
```
```:結果
All matched substrings: [1 2 3 4 5 6]
```
#### 例：任意の単語文字に一致
```go:例
package main

import (
    "fmt"
    "regexp"
)

func main() {
    pattern := `\w`
    re, _ := regexp.Compile(pattern)
    text := "123 abc 456 def"
    matches := re.FindAllString(text, -1)
    fmt.Println("All matched substrings:", matches)
}
```
```:結果
All matched substrings: [1 2 3 a b c 4 5 6 d e f]
```
#### 例：任意の空白文字に一致
```go:例
package main

import (
    "fmt"
    "regexp"
)

func main() {
    pattern := `\s`
    re, _ := regexp.Compile(pattern)
    text := "123 abc 456 def"
    matches := re.FindAllString(text, -1)
    fmt.Println("All matched substrings:", matches)
}
```
```:結果
All matched substrings: [     ]
```
#### 例：単語の境界に一致
```go:例
package main

import (
    "fmt"
    "regexp"
)

func main() {
    pattern := `\bword\b`
    re, _ := regexp.Compile(pattern)
    text := "word words sword"
    matches := re.FindAllString(text, -1)
    fmt.Println("All matched substrings:", matches)
}
```
```:結果
All matched substrings: [word]
```
## まとめ
Go言語のregexpパッケージを使用することで、正規表現を簡単に扱うことができます。正規表現を使用して文字列のパターンマッチングや検索、置換を行う方法を学びました。詳細な情報や最新の更新については、Goの公式（ https://pkg.go.dev/regexp ）を参照してください。