List of Regular-Expression [text.Baldanders.info]

Writers パッケージを作ってみた

2020-03-28T11:40:05+00:00

Twitter で

できればLogレベルでファイル分割したいところですが、Goの情報はなかなか見つからなかった...。

Trace/Debug/Info/Warning
Error/Fatal
とかいう好きな単位でログファイルを切り替えられれば、別ツイのtail -f時のノイズ削減になりそう。https://t.co/MTyoOqyvgQ
(分割について記載なすび)
— SIG (@sig_246) March 26, 2020

というのを見かけたので，試しに作ってみた。

spiegel-im-spiegel/writers: Filtering Writer

いや tee および grep コマンドを組み合わせれば出力の分割はできるんだけどね¹。まぁ，言語的に面白いトピックはないし，手遊びということで。

たとえば，拙作の logf パッケージを使ってこんなログ出力を考えてみる。

package main

import (
    "os"

    "github.com/spiegel-im-spiegel/logf"
)

func main() {
    logf.SetOutput(os.Stdout)
    for i := 0; i < 6; i++ {
        logf.SetMinLevel(logf.TRACE + logf.Level(i))
        logf.Tracef("Traceing: No. %d\n", i+1)
        logf.Debugf("Debugging: No. %d\n", i+1)
        logf.Printf("Information: No. %d\n", i+1)
        logf.Warnf("Warning: No. %d\n", i+1)
        logf.Errorf("Erroring: No. %d\n", i+1)
        logf.Fatalf("Fatal Erroring: No. %d\n", i+1)
    }
}

これを実行すると，こんな感じになる。

$ go run sample.go
2020/03/28 14:44:44 [TRACE] Traceing: No. 1
2020/03/28 14:44:44 [DEBUG] Debugging: No. 1
2020/03/28 14:44:44 [INFO] Information: No. 1
2020/03/28 14:44:44 [WARN] Warning: No. 1
2020/03/28 14:44:44 [ERROR] Erroring: No. 1
2020/03/28 14:44:44 [FATAL] Fatal Erroring: No. 1
2020/03/28 14:44:44 [DEBUG] Debugging: No. 2
2020/03/28 14:44:44 [INFO] Information: No. 2
2020/03/28 14:44:44 [WARN] Warning: No. 2
2020/03/28 14:44:44 [ERROR] Erroring: No. 2
2020/03/28 14:44:44 [FATAL] Fatal Erroring: No. 2
2020/03/28 14:44:44 [INFO] Information: No. 3
2020/03/28 14:44:44 [WARN] Warning: No. 3
2020/03/28 14:44:44 [ERROR] Erroring: No. 3
2020/03/28 14:44:44 [FATAL] Fatal Erroring: No. 3
2020/03/28 14:44:44 [WARN] Warning: No. 4
2020/03/28 14:44:44 [ERROR] Erroring: No. 4
2020/03/28 14:44:44 [FATAL] Fatal Erroring: No. 4
2020/03/28 14:44:44 [ERROR] Erroring: No. 5
2020/03/28 14:44:44 [FATAL] Fatal Erroring: No. 5
2020/03/28 14:44:44 [FATAL] Fatal Erroring: No. 6

これを出発点とする。

出力を多重化するには io.MultiWriter() 関数を使うとよい。こんな感じ。

package main

import (
    "fmt"
    "io"
    "os"

    "github.com/spiegel-im-spiegel/logf"
)

func main() {
    file, err := os.Create("log.txt")
    if err != nil {
        fmt.Printf("%#v\n", err)
        return
    }
    defer file.Close()

    ws := io.MultiWriter(
        file,
        os.Stdout,
    )
    logf.SetOutput(ws)
    for i := 0; i < 6; i++ {
        logf.SetMinLevel(logf.TRACE + logf.Level(i))
        logf.Tracef("Traceing: No. %d\n", i+1)
        logf.Debugf("Debugging: No. %d\n", i+1)
        logf.Printf("Information: No. %d\n", i+1)
        logf.Warnf("Warning: No. %d\n", i+1)
        logf.Errorf("Erroring: No. %d\n", i+1)
        logf.Fatalf("Fatal Erroring: No. %d\n", i+1)
    }
}

これで標準出力と log.txt ファイルに全く同じ内容が出力される。

次に，標準出力には [ERROR] と [FATAL] のログのみ出力したい。そこでこんな型を考える。

package writers

//FilterWriter type is Writer with filter
type FilterWriter struct {
    word   []byte
    writer io.Writer
}

この型に対して以下の Write() メソッド

//Write function writes bytes data.
func (w *FilterWriter) Write(b []byte) (int, error) {
    if w.match(b) {
        return w.writer.Write(b)
    }
    return len(b), nil
}

func (w *FilterWriter) match(b []byte) bool {
    if len(b) == 0 {
        return false
    }
    if w.word == nil {
        return true
    }
    return bytes.Contains(b, w.word)
}

を組み込めば，設定したキーワードを含んでいる場合のみ書き込みを行うようになる。

writers.FilterWriter を使って先程のコードを書き換えてみよう。こんな感じ。

package main

import (
    "fmt"
    "io"
    "os"

    "github.com/spiegel-im-spiegel/logf"
    "github.com/spiegel-im-spiegel/writers"
)

func main() {
    file, err := os.Create("log.txt")
    if err != nil {
        fmt.Printf("%#v\n", err)
        return
    }
    defer file.Close()

    ws := io.MultiWriter(
        file,
        writers.Filter(os.Stdout, []byte("[ERROR]")),
		writers.Filter(os.Stdout, []byte("[FATAL]")),
    )
    logf.SetOutput(ws)
    for i := 0; i < 6; i++ {
        logf.SetMinLevel(logf.TRACE + logf.Level(i))
        logf.Tracef("Traceing: No. %d\n", i+1)
        logf.Debugf("Debugging: No. %d\n", i+1)
        logf.Printf("Information: No. %d\n", i+1)
        logf.Warnf("Warning: No. %d\n", i+1)
        logf.Errorf("Erroring: No. %d\n", i+1)
        logf.Fatalf("Fatal Erroring: No. %d\n", i+1)
    }
}

これで標準出力が

$ go run sample.go
2020/03/28 14:44:44 [ERROR] Erroring: No. 1
2020/03/28 14:44:44 [FATAL] Fatal Erroring: No. 1
2020/03/28 14:44:44 [ERROR] Erroring: No. 2
2020/03/28 14:44:44 [FATAL] Fatal Erroring: No. 2
2020/03/28 14:44:44 [ERROR] Erroring: No. 3
2020/03/28 14:44:44 [FATAL] Fatal Erroring: No. 3
2020/03/28 14:44:44 [ERROR] Erroring: No. 4
2020/03/28 14:44:44 [FATAL] Fatal Erroring: No. 4
2020/03/28 14:44:44 [ERROR] Erroring: No. 5
2020/03/28 14:44:44 [FATAL] Fatal Erroring: No. 5
2020/03/28 14:44:44 [FATAL] Fatal Erroring: No. 6

となった。

単純な比較のみだと複雑なパターンを構成し辛いので，正規表現バージョンも作ってみた。

//RegexpWriter type is Writer with regular expression filter
type RegexpWriter struct {
    re     *regexp.Regexp
    writer io.Writer
}

//WriteString function writes string.
func (w *RegexpWriter) Write(b []byte) (int, error) {
    if w.match(b) {
        return w.writer.Write(b)
    }
    return len(b), nil
}

func (w *RegexpWriter) match(b []byte) bool {
    if len(b) == 0 {
        return false
    }
    if w.re == nil {
        return true
    }
    return w.re.Match(b)
}

これを使えば，先程のコードはこんな感じにできる。

package main

import (
    "fmt"
    "io"
    "os"
    "regexp"

    "github.com/spiegel-im-spiegel/logf"
    "github.com/spiegel-im-spiegel/writers"
)

func main() {
    file, err := os.Create("log.txt")
    if err != nil {
        fmt.Printf("%#v\n", err)
        return
    }
    defer file.Close()

    ws := io.MultiWriter(
        file,
        writers.FilterRegexp(os.Stdout, regexp.MustCompile(`\[(ERROR|FATAL)\]`)),
    )
    logf.SetOutput(ws)
    for i := 0; i < 6; i++ {
        logf.SetMinLevel(logf.TRACE + logf.Level(i))
        logf.Tracef("Traceing: No. %d\n", i+1)
        logf.Debugf("Debugging: No. %d\n", i+1)
        logf.Printf("Information: No. %d\n", i+1)
        logf.Warnf("Warning: No. %d\n", i+1)
        logf.Errorf("Erroring: No. %d\n", i+1)
        logf.Fatalf("Fatal Erroring: No. %d\n", i+1)
    }
}

これで同じ結果が得られる。

今回はベースの Writer に出力多重化やらフィルタやらの機能を被せているだけなので，色々と応用が効くだろう。効くといいな（笑）

ブックマーク

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

著者のひとりは（あの「バイブル」とも呼ばれる）通称 “K&R” の K のほうである。この本は Go 言語の教科書と言ってもいいだろう。と思ったら絶版状態らしい（2025-01 現在）。復刊を望む！

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

ちなみに Go の標準パッケージにも io.TeeReader() 関数ってのがあって tee コマンドと同等のことができる。 ↩︎

Go 1.12 がリリースされた

2019-02-26T14:03:40+00:00

Go 1.12 がリリースされた。そういえば2月ももう終わりか。

主な変更点としては TLS 1.3 の暫定的なサポート（有効にするには環境変数の設定が必要）とモジュール・モードの挙動の一部が変わったことだろうか。

たとえば環境変数 $GO111MODULE を on にしておけば mattn さんの jvgrep をインストールする際にも任意のフォルダで

$ go get github.com/mattn/jvgrep@latest

とすればよい。ダミーの go.mod ファイルを作る必要はなくなった。ブラボー！

Go 1.13 からはモジュール・モードが既定になるようで，「GOPATH モードじゃないと困る」とかじゃなければ環境変数 $GO111MODULE は on のままにしてしまえばいいんじゃないのかなぁ。

あと地味だが嬉しい変更としては，並行処理下で正規表現パッケージ regexp を使う際に regexp.Regexp.Copy() でクローンを作らなくてもブロッキングが起きないようになった。

Go 言語はこの 1.12 から 1.13 にかけて大きく変わる予感がする（今のところ後方互換性は確保されるだろうが）。色々と試していって慣れていくのがいいかもしれない。

ブックマーク

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

Go言語による並行処理: Katherine Cox-Buday (著), 山口能迪 (翻訳); オライリージャパン 2018-10-26; 単行本（ソフトカバー）; 4873118468 (ASIN), 9784873118468 (EAN), 4873118468 (ISBN); 評価

Eブック版もある。感想はこちら。 Go 言語で並行処理を書くならこの本は必読書になるだろう。

reviewed by Spiegel on 2020-01-13 (powered by PA-APIv5)

正規表現に関する戯れ言

2018-04-17T15:28:41+00:00

以下の記事を見て思いついたことを戯れ言として書いておく。コード少な目でゴメンペコン（どっちのセクションで書こうか悩んだ）。

Golangの正規表現がどれぐらいおそいのかをPythonと比較してみた話 - Qiita

詳しい解説はブックマークにある記事を参照のこと。

正規表現 regexp パッケージは（概ね）遅い

そもそも正規表現（regular expression）は，それ自体が言語の一種と言える¹。スクリプト言語のように言語仕様の一部として組み込まれている場合は別だが， Go 言語のようなコンパイル言語の場合，普通は（言語本体ではなく）ライブラリやフレームワークの一部として組み込まれる。

Go 言語標準の正規表現エンジンである regexp パッケージは（Perl や Ruby といった言語に比べて）概ね遅い。これは本当である。 regexp パッケージの設計方針について以下のような記述がある。

The regexp implementation provided by this package is guaranteed to run in time linear in the size of the input.

via regexp - The Go Programming Language

まぁぶっちゃけて言うと regexp パッケージは「遅くなりすぎない」ように作られているのだ²。

strings パッケージを使え

その代わりと言ってはナニだが Go 言語では文字列検索や操作のための strings や unicode といった標準パッケージが充実している。例えば，単純な前方一致や後方一致なら strings.HasPrefix() 関数や strings.HasSuffix() 関数を使いやがれ，みたいな感じ。

ただ，正規表現を使うことでコードの可読性が上がる（ことによってバグ混入リスクを減らせる）ことは確かなので，状況によってパッケージを使い分けるのがコツである。

regexp パッケージ利用のコツ

regexp パッケージを使う場合はちょっとした工夫が必要となる。

まず正規表現のコンパイルにはそこそこのコストがかかるため，できるだけ使いまわすようにする。固定の正規表現ならグローバル変数として初期化してしまうのも手である³。

var re = regexp.MustCompile("^[0-9a-fA-F]+$")

複数の正規表現を動的に切り替えるのであれば map 等を使ってコンパイル結果をキャッシュするのもいいかもしれない。

さらに正規表現による評価を実行する際は排他制御がかかるため，並行処理下でコンパイル済みインスタンスをそのまま使うとパフォーマンスが落ちる。そこで regexp.Regexp.Copy() 関数を使ってインスタンスのコピーを生成し，コピーを使って評価を行う。

if !re.Copy().MatchString(s) {
    fmt.Println(s, "is not hexadecimal.")
}

【追記 2019-02-26】 Go 1.12 からは regexp.Regexp.Copy() 関数は必要なくなった。ブラボー！

その正規表現ホンマにいるの？

いや，便利なのは分かるんだけどさ，「その正規表現ホンマにいるの？」ってのがあるのよ，たまに。私もやっつけのコードだと正規表現で済ますことがあるけど。

どうしても正規表現が必要で Perl や Ruby といった他言語のほうがシステム全体のパフォーマンスがいいというのであれば，それらの言語を使えばいいと思う。もしくは正規表現パッケージを自作するか。

個人的に「言語の選択は適材適所」と思ってるので，無理に Go 言語にこだわる必要はないと思う。もちろん遊びでやるのなら好きにすればいいんだけど。

ブックマーク

Regular Expression Matching Can Be Simple And Fast
regexpとの付き合い方〜 Go言語標準の正規表現ライブラリのパフォーマンスとアルゴリズム〜 | eureka tech blog
正規表現チェッカー（JavaScript版） | Softel labs
40行以内で正規表現エンジンを構築 | プログラミング | POSTD
[[Go] パフォーマンスが悪い正規表現パッケージの使い方をチェックするlinterを作った - My External Storage](https://budougumi0617.github.io/2020/08/20/regexponce/) : regexp パッケージ用の linter らしい

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

数学の数式だって言語の一種と考えられるのなら正規表現も言語の一種と考えてさしつかえないだろう。 ↩︎
詳しくは “Regular Expression Matching Can Be Simple And Fast” を参照のこと。 ↩︎
regexp.MustCompile() 関数では，コンパイルに失敗すると panic を投げる。通常は regexp.Compile() 関数を使い，返り値の error をチェックする。 ↩︎

指定桁の数字列の先頭をゼロで埋める遊び

2017-10-09T08:05:06+00:00

一応予防線を張っておくけど，この記事のコードをそのまま業務に使わないように。まんず，そがな人はおらんじゃろけど。

さて，今日は体育の日だし頭の体操ということで「指定桁数の数字列の先頭をゼロで埋める遊び」をやってみる。たとえば指定桁が4桁で，与えられる数字列が “123” なら， “0123” に整形するということである。以下に要求をまとめよう。

桁数は1以上の数値，数字列は長さ0以上の文字列で与えられる
数字列について 0-9 の数字のみ許可（+ / - 等の符号は考慮しない）
与えられた数字列の長さが桁数より小さい場合は先頭をゼロ “0” で埋めて返す（4桁： 123 → 0123）
与えられた数字列の長さが桁数より大きい場合は下の桁を桁数分返す（4桁： 12345 → 2345）

この機能を CLI (Command Line Interface) で表現することを考える。こんな感じでどうだろう。

$ fillzero -h
Usage: fillzero -n <number of digits> [digit string]

このインタフェースを実装する main() 関数はこんな感じかな。

package main

import (
    "flag"
    "fmt"
    "os"
)

//Run returns error status in proess.
func Run(args []string) error {
    //initialize flag options
    f := flag.NewFlagSet("fillzero", flag.ContinueOnError)
    f.Usage = func() {
        fmt.Fprintln(os.Stderr, "Usage: fillzero -n <number of digits> [digit string]")
    }
    n := f.Int("n", 0, "number of digits")

    //parse arguments
    if err := f.Parse(args); err != nil {
        return os.ErrInvalid
    }
    if f.NArg() > 1 {
        f.Usage()
        return errors.New("Too many arguments.")
    }

    // get digit string
    var s string
    if f.NArg() == 1 {
        s = f.Arg(0)
    }

    // Fill in digits...

    fmt.Println(s)
    return nil
}

func main() {
    if err := Run(os.Args[1:]); err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }
    os.Exit(0)
}

これであとは s = fillzero(*n, s) みたいな関数をでっち上げればいいのだが，私は天邪鬼なので別のことを考えた。つまり「指定桁数の数字列の先頭をゼロで埋める」機能を持つ value object を作ったほうが面白いよね。

たとえばこんな感じ。

//Identity is digit string class
type Identity struct {
    ds string // digit string
    nd int    // number of digits
}

これに対してインスタンスを生成する New() 関数と，整形済みの文字列を吐き出す Stringer を組み込んであげればいい。最終的にはこんな感じになる。

package main

import (
    "errors"
    "flag"
    "fmt"
    "os"
    "regexp"
    "strings"
)

//regular expression object for Identity class
var re = regexp.MustCompile(`^[0-9]+$`)

//Identity is digit string class
type Identity struct {
    ds string // digit string
    nd int    // number of digits
}

//IdentityNew returns Identity instance.
func IdentityNew(n int, s string) (*Identity, error) {
    d := &Identity{}
    if n <= 0 {
        return d, errors.New("Number of digits is greater than zero.")
    }
    if len(s) > 0 {
        if !re.Copy().MatchString(s) {
            return d, errors.New(s + " is not digit string.")
        }
    }
    d.nd = n
    d.ds = s
    return d, nil
}

//String is Stringer method
func (id *Identity) String() string {
    if id.nd <= 0 {
        return ""
    }
    l := len(id.ds)
    if id.nd == l {
        return id.ds
    } else if id.nd < l {
        return id.ds[l-id.nd:]
    }
    return strings.Repeat("0", id.nd-l) + id.ds
}

//Run returns error status in proess.
func Run(args []string) error {
    //initialize flag options
    f := flag.NewFlagSet("fillzero", flag.ContinueOnError)
    f.Usage = func() {
        fmt.Fprintln(os.Stderr, "Usage: fillzero -n <number of digits> [digit string]")
    }
    n := f.Int("n", 0, "number of digits")

    //parse arguments
    if err := f.Parse(args); err != nil {
        return os.ErrInvalid
    }
    if f.NArg() > 1 {
        f.Usage()
        return errors.New("Too many arguments.")
    }

    // get digit string
    var s string
    if f.NArg() == 1 {
        s = f.Arg(0)
    }

    d, err := IdentityNew(*n, s)
    if err != nil {
        return err
    }
    fmt.Println(d)

    return nil
}

func main() {
    if err := Run(os.Args[1:]); err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }
    os.Exit(0)
}

本来なら別パッケージにして identity.Identity みたいにするのがいいんだろうけど（テストも書きやすいし），ファイルを分けたり面倒なことになるので端折っている。また，文字列のチェックに正規表現を扱える regexp パッケージを使った¹ が，正直に言ってこの程度の処理に正規表現パッケージを使うのが効率的かどうかは分からない（コードはすっきりするけど）。

実際に動かしてみると，こんな感じになる。

$ fillzero -n 4
0000
$ fillzero -n 4 123
0123
$ fillzero -n 4 1234
1234
$ fillzero -n 4 12345
2345

要求は満たしているな。よしよし。

値と機能を value object にパッケージングすると，別の実装も考えることができる。たとえば数字列を文字列のまま保持するのではなく数値で保持するとか。

//Identity is digit string class
type Identity struct {
    id uint64 // identity
    nd int    // number of digits
}

//IdentityNew returns Identity instance.
func IdentityNew(n int, s string) (*Identity, error) {
    id := &Identity{}
    if n <= 0 {
        return id, errors.New("Number of digits is greater than zero.")
    }
    if len(s) > 0 {
        i, err := strconv.ParseUint(s, 10, 64)
        if err != nil {
            return id, err
        }
        id.id = i
    }
    id.nd = n
    return id, nil
}

//String is Stringer method
func (id *Identity) String() string {
    if id.nd <= 0 {
        return ""
    }
    s := strconv.FormatUint(id.id, 10)
    l := len(s)
    if id.nd == l {
        return s
    } else if id.nd < l {
        return s[l-id.nd:]
    }
    return strings.Repeat("0", id.nd-l) + s
}

これにまるっと入れ替えても概ね同じ結果になる²。数字列に対して何らかの数値演算を行う機能が必要ならこちらのほうがいいかもしれない。ちなみに uint64 を使ったことに特に意味はなくて，ぶっちゃけ「大は小を兼ねる」ってやつだが，このサイズで足りなければ big.Int を使う必要がある。

って，ここまで考えたけど，やっぱ具体的な業務の中で考えないと意味ないよね（笑）まぁ，今回は文字列⇔数値変換と正規表現（のさわり）について書けたからよしとするか。

ブックマーク

regexp.Compile() 関数は処理コストがかかるためグローバル変数として宣言・初期化している。ちなみに regexp.MustCompile() 関数は，コンパイルに失敗すると panic を吐く。コンパイルで生成したグローバルなインスタンスを使う場合は，インスタンスをそのまま使うのではなく Copy() 関数でコピーを作る習慣をつけるとよい。今回のサンプル・コードではそのまま使っても影響はないが，並行処理下ではインスタンス使用時にロックが掛かるためコピーが必須となる。 ↩︎
厳密に言うと数字列をいきなり strconv.ParseUint() 関数にかけているので数値として表現可能なものは通ってしまう。たとえば + / - の符号などだ。そういう意味では要求からの逸脱（deviation）があるのだが，所詮お遊びなので目をつむって欲しい。実際には数字列のチェック処理は別関数にした方がいいと思う。 ↩︎