std.regex

import std.regex;
import std.stdio;
// ユーザ入力から見つかったdd/mm/yy(yy)の可能な日付をすべて出力する。
auto r = regex(r"\b[0-9][0-9]?/[0-9][0-9]?/[0-9][0-9](?:[0-9][0-9])?\b");
foreach (line; stdin.byLine)
{
  // matchAll()は、その後に続く全てのマッチを
  // 得るために反復可能な範囲を返す。
  foreach (c; matchAll(line, r))
      writeln(c.hit);
}

import std.regex;
auto ctr = ctRegex!(`^.*/([^/]+)/?$`);

// 通常の正規表現と同じように動作する:
auto c2 = matchFirst("foo/bar", ctr);   // 最初に一致するものがあれば、
assert(!c2.empty);   // ここで見つかる内容を確認する前に、必ず一致するかどうかを確認すること!
assert(c2[1] == "bar");   // キャプチャはサブマッチの範囲である: 0 = 完全一致。

import std.regex;
auto multi = regex([`\d+,\d+`, `([a-z]+):(\d+)`]);
auto m = "abc:43 12,34".matchAll(multi);
assert(m.front.whichPattern == 2);
assert(m.front[1] == "abc");
assert(m.front[2] == "43");
m.popFront();
assert(m.front.whichPattern == 1);
assert(m.front[0] == "12,34");

import std.regex;
// `matchAll/matchFirst`の結果は、`if/assert/while`で直接テストできる、
// 例えば、文字列が文字のみで構成されているかどうかを調べることができる:
assert(matchFirst("LettersOnly", `^\p{L}+$`));

// また、IfConditionの中で変数を定義する機能を利用することもできる:
if (const captures = matchFirst("At l34st one digit, but maybe more...", `((\d)(\d*))`))
{
    assert(captures[2] == "3");
    assert(captures[3] == "4");
    assert(captures[1] == "34");
}

template Regex(Char)

Regexオブジェクトは正規表現パターンをコンパイルした形で保持する。

このオブジェクトのインスタンスは、regex を呼び出すことで生成される。 これは、頻繁に使われる正規表現のキャッシュと保存を目的としたものである。 これは、頻繁に使用される正規表現のキャッシュと保存を目的とした形式である。

例: このオブジェクトにコンパイルされたパターンが含まれていないかテストする。

Regex!char r;
assert(r.empty);
r = regex(""); // 注釈: ""は有効な正規表現パターンである。
assert(!r.empty);

正規表現内のすべての名前付きキャプチャの範囲を取得する。

import std.range;
import std.algorithm;

auto re = regex(`(?P<name>\w+) = (?P<var>\d+)`);
auto nc = re.namedCaptures;
static assert(isRandomAccessRange!(typeof(nc)));
assert(!nc.empty);
assert(nc.length == 2);
assert(nc.equal(["name", "var"]));
assert(nc[0] == "name");
assert(nc[1..$].equal(["var"]));

alias StaticRegex = Regex(Char);

A StaticRegexはRegex オブジェクトである。 を含むオブジェクトである。

もはや使用されていないが、後方互換性のためにRegexのエイリアスとして保持されている。

@trusted auto regex(S : C[], C)(const S[] patterns, const(char)[] flags = "")
if (isSomeString!S);

@trusted auto regex(S)(S pattern, const(char)[] flags = "")
if (isSomeString!S);

後で実行するために正規表現パターンをコンパイルする。

Returns:

Regex オブジェクトは と同じ文字幅を持つ入力に対して動作する pattern.

Parameters:

S pattern	マッチさせる1つの正規表現。
S[] patterns	正規表現文字列の配列。 結果のRegex オブジェクトは、どの正規表現にもマッチする; どの正規表現にマッチするかを知るには whichPatternを使う。
const(char)[] flags	属性(g, i, m, s, xが使える)

Throws:

RegexException コンパイル時にエラーがあった場合

Examples:

void test(S)()
{
    // マルチパターン正規表現の例
    S[] arr = [`([a-z]+):(\d+)`, `(\d+),\d+`];
    auto multi = regex(arr); // マルチ正規表現
    S str = "abc:43 12,34";
    auto m = str.matchAll(multi);
    writeln(m.front.whichPattern); // 1
    writeln(m.front[1]); // "abc"
    writeln(m.front[2]); // "43"
    m.popFront();
    writeln(m.front.whichPattern); // 2
    writeln(m.front[1]); // "12"
}

import std.meta : AliasSeq;
static foreach (C; AliasSeq!(string, wstring, dstring))
    // パターンの定数配列でテストする - https://issues.dlang.org/show_bug.cgi?id=20301を参照のこと
    static foreach (S; AliasSeq!(C, const C, immutable C))
        test!S();

enum auto ctRegex(alias pattern, string flags = "");

CTFEを使って正規表現をコンパイルする。 を使用して正規表現をコンパイルし、それにマッチするように最適化されたネイティブ・マシン・コードを生成する。

Returns:

より高速なマッチングのためのStaticRegexオブジェクト。

Parameters:

pattern	正規表現
flags	属性(g、i、m、s、xを受け付ける)

struct Captures(R) if (isSomeString!R);

Capturesオブジェクトは、 の呼び出しや、 の範囲に対する反復処理中にキャプチャされたサブマッチを含んでいる。 match を呼び出したり、RegexMatch の範囲を反復したりする際に捕捉されたサブマッチが含まれる。

範囲の最初の要素はマッチ全体である。

Examples:

import std.range.primitives : popFrontN;

auto c = matchFirst("@abc#", regex(`(\w)(\w)(\w)`));
assert(c.pre == "@"); // マッチに先立つ入力の一部
assert(c.post == "#"); // マッチ直後
assert(c.hit == c[0] && c.hit == "abc"); // マッチ全体
writeln(c[2]); // "b"
writeln(c.front); // "abc"
c.popFront();
writeln(c.front); // "a"
writeln(c.back); // "c"
c.popBack();
writeln(c.back); // "b"
popFrontN(c, 2);
assert(c.empty);

assert(!matchFirst("nothing", "something"));

// マッチしなかったキャプチャはnullになる。
c = matchFirst("ac", regex(`a(b)?c`));
assert(c);
assert(!c[1]);

@property R pre();

試合前のインプットのスライス

@property R post();

マッチ直後の入力のスライス。

@property R hit();

入力のマッチした部分のスライス。

@property R front();

@property R back();

void popFront();

void popBack();

const @property bool empty();

inout inout(R) opIndex()(size_t i);

範囲インターフェイス。

const nothrow @safe bool opCast(T : bool)();

boolへの明示的キャスト。 if文やassert文の!(x.empty)の省略形として便利。

import std.regex;

assert(!matchFirst("nothing", "something"));

const nothrow @property @safe int whichPattern();

パターンにマッチした数を数える。 マッチしない場合は0を返す。

Examples:

import std.regex;
writeln(matchFirst("abc", "[0-9]+", "[a-z]+").whichPattern); // 2

R opIndex(String)(String i)
if (isSomeString!String);

名前付きサブマッチを検索する。

import std.regex;
import std.range;

auto c = matchFirst("a = 42;", regex(`(?P<var>\w+)\s*=\s*(?P<value>\d+);`));
assert(c["var"] == "a");
assert(c["value"] == "42");
popFrontN(c, 2);
// 名前付きグループは範囲プリミティブの影響を受けない
assert(c["var"] =="a");
assert(c.front == "42");

const @property size_t length();

このオブジェクトのマッチ数。

@property ref auto captures();

オリジナルのstd.regexとの互換性のためのフック。

struct RegexMatch(R) if (isSomeString!R);

match ファミリーの関数が返す正規表現エンジンの状態。

事実上、Captures!Rの前方範囲である。 の前方範囲である。

@property R pre();

@property R post();

@property R hit();

front.pre、front.post、front.hitの短縮形である。

inout @property inout(Captures!R) front();

void popFront();

auto save();

範囲インターフェイスを介してグローバル正規表現の後続のマッチを処理する機能:

import std.regex;
auto m = matchAll("Hello, world!", regex(`\w+`));
assert(m.front.hit == "Hello");
m.popFront();
assert(m.front.hit == "world");
m.popFront();
assert(m.empty);

const @property bool empty();

このマッチオブジェクトが空かどうかをテストする。

T opCast(T : bool)();

(x.empty)と同じで、条件文での利便性のために提供される。

inout @property inout(Captures!R) captures();

.frontと同じで、元のstd.regexとの互換性のために提供される。

auto match(R, RegEx)(R input, RegEx re)
if (isSomeString!R && isRegexFor!(RegEx, R));

auto match(R, String)(R input, String re)
if (isSomeString!R && isSomeString!String);

マッチを開始する input正規表現パターン re, にマッチングを開始する。

この関数の使用は推奨されない。 matchAllまたは matchFirst.

操作の種類を "g"フラグに委ねる を "g"フラグに委譲することは、正確なマッチング方式を選択する機能とともに、まもなく廃止される予定である。 正確なマッチング方式を選択する機能とともに廃止される。どの 使用するマッチングスキームの選択はパターンの種類に大きく依存する。 ケースバイケースで自動的に行われる。

Returns:

最初のマッチ後のエンジン状態を保持するRegexMatch オブジェクト。

auto matchFirst(R, RegEx)(R input, RegEx re)
if (isSomeString!R && isRegexFor!(RegEx, R));

auto matchFirst(R, String)(R input, String re)
if (isSomeString!R && isSomeString!String);

auto matchFirst(R, String)(R input, String[] re...)
if (isSomeString!R && isSomeString!String);

の最初の(左端の)スライスを見つける。 inputその パターンにマッチする re.この"関数"は、パターンのプロパティに応じて最適な正規表現エンジンを選ぶ。 正規表現エンジンを選ぶ。

reパラメータには3つの型がある:

• プレーンな文字列。この場合、マッチング前にバイトコードにコンパイルされる。
• Regex!char(wchar/dchar):コンパイルされたバイトコード形式のパターンを含む。 バイトコードにコンパイルされる。
• staticRegex!char(wchar/dchar)で、コンパイルされたネイティブ・マシンコード形式のパターンを含む。 コンパイルされたネイティブ・マシン・コードの形でパターンを含む。

Returns:

Capturesマッチの範囲とすべてのサブマッチを含む。 を含む。 Capturesオブジェクトを含む。

auto matchAll(R, RegEx)(R input, RegEx re)
if (isSomeString!R && isRegexFor!(RegEx, R));

auto matchAll(R, String)(R input, String re)
if (isSomeString!R && isSomeString!String);

auto matchAll(R, String)(R input, String[] re...)
if (isSomeString!R && isSomeString!String);

パターンに重複しないすべてのマッチの検索を開始する。 re に重ならないすべてのマッチを検索する。 input.その結果は、入力の左から右にマッチしたときに生成される が生成される。

この"関数"は、パターンの性質に応じて、最も適切な正規表現エンジンを選ぶ。 を選ぶ。

reパラメータには3つの型がある:

• プレーン文字列(この場合、マッチング前にバイトコードにコンパイルされる)。
• Regex!char(wchar/dchar):コンパイルされたバイトコード形式のパターンを含む。 バイトコードにコンパイルされる。
• staticRegex!char(wchar/dchar)で、コンパイルされたネイティブ・マシンコード形式のパターンを含む。 コンパイルされたネイティブ・マシン・コードの形でパターンを含む。

Returns:

RegexMatchマッチャーの状態を表す オブジェクトを返す。

auto bmatch(R, RegEx)(R input, RegEx re)
if (isSomeString!R && isRegexFor!(RegEx, R));

auto bmatch(R, String)(R input, String re)
if (isSomeString!R && isSomeString!String);

正規表現パターンへの input正規表現パターン re, のマッチングを開始する。

この関数の使用は推奨されない。 matchAllまたは matchFirst.

操作の種類を "g"フラグに委ねる を "g"フラグに委譲することは、正確なマッチング方式を選択する機能とともに、まもなく廃止される予定である。 正確なマッチング方式を選択する機能とともに廃止される。どの 使用するマッチングスキームの選択はパターンの種類に大きく依存する。 ケースバイケースで自動的に行われる。

Returns:

RegexMatch オブジェクトはエンジン オブジェクトを保持する。

R replaceFirst(R, C, RegEx)(R input, RegEx re, const(C)[] format)
if (isSomeString!R && is(C : dchar) && isRegexFor!(RegEx, R));

から新しい文字列を作る。 inputから新しい文字列を構築する。 指定子に従って生成された文字列と置き換えることで format指定子に従って生成された文字列に置き換えることで、新しい文字列を構築する。

すべてのマッチを置き換えるには replaceAll.

Parameters:

R input	検索する文字列
RegEx re	使用するコンパイルされた正規表現
const(C)[] format	置換を生成するためのフォーマット文字列、 フォーマット文字列を参照のこと。

Returns:

最初にマッチした文字列(もしあれば)が置換された同じ型の文字列を返す。 マッチしない場合は、入力文字列そのものを返す。

Examples:

writeln(replaceFirst("noon", regex("n"), "[$&]")); // "[n]oon"

R replaceFirst(alias fun, R, RegEx)(R input, RegEx re)
if (isSomeString!R && isRegexFor!(RegEx, R));

これは一般的な置換ツールであり、以下のようなパターンにマッチする文字列を置換して新しい文字列を作成する。 パターン reにマッチする文字列を input.他のオーバーロード に渡される。 に渡され、ユーザー定義のファンクタfun 。 に渡される。

このバージョンでは input, を参照のこと。 replaceAllですべてのマッチを置き換える。

Returns:

と同じ型の新しい文字列。 inputと同じ型の新しい文字列を返す。 fun の戻り値に置き換えられる。 を返す。 inputそのものを返す。

Examples:

import std.conv : to;
string list = "#21 out of 46";
string newList = replaceFirst!(cap => to!string(to!int(cap.hit)+1))
    (list, regex(`[0-9]+`));
writeln(newList); // "#22 out of 46"

@trusted void replaceFirstInto(Sink, R, C, RegEx)(ref Sink sink, R input, RegEx re, const(C)[] format)
if (isOutputRange!(Sink, dchar) && isSomeString!R && is(C : dchar) && isRegexFor!(RegEx, R));

@trusted void replaceFirstInto(alias fun, Sink, R, RegEx)(Sink sink, R input, RegEx re)
if (isOutputRange!(Sink, dchar) && isSomeString!R && isRegexFor!(RegEx, R));

のバリエーションだ。 replaceFirstのバリエーションである。 に分割して出力する。 sink.特に これは、最終出力をインクリメンタルに効率的に構築することを可能にする。

のように replaceFirst関数 "ファミリーのように、オーバーロードがある。 によって導かれる置換のためのオーバーロードがある。 format文字列 とユーザー定義のコールバックを持つものがある。

Examples:

import std.array;
string m1 = "first message\n";
string m2 = "second message\n";
auto result = appender!string();
replaceFirstInto(result, m1, regex(`([a-z]+) message`), "$1");
// ユーザー定義のコールバックを持つ上記と同等のもの
replaceFirstInto!(cap=>cap[1])(result, m2, regex(`([a-z]+) message`));
writeln(result.data); // "first\nsecond\n"

@trusted R replaceAll(R, C, RegEx)(R input, RegEx re, const(C)[] format)
if (isSomeString!R && is(C : dchar) && isRegexFor!(RegEx, R));

から新しい文字列を作成する。 inputパターン パターン reにマッチするすべてのフラグメントを 指定子に従って生成された文字列で置き換える。 format指定子に従って生成された文字列に置き換える。

最初のマッチだけを置き換えるには replaceFirst.

Parameters:

R input	検索する文字列
RegEx re	使用するコンパイルされた正規表現
const(C)[] format	置換を生成するためのフォーマット文字列、 フォーマット文字列を参照のこと。

Returns:

と同じ型の文字列である。 inputと同じ型の文字列で と同じ型の文字列を返す。 マッチしない場合は、入力文字列そのものを返す。

Examples:

// insert comma as thousands delimiter
auto re = regex(r"(?<=\d)(?=(\d\d\d)+\b)","g");
writeln(replaceAll("12000 + 42100 = 54100", re, ",")); // "12,000 + 42,100 = 54,100"

@trusted R replaceAll(alias fun, R, RegEx)(R input, RegEx re)
if (isSomeString!R && isRegexFor!(RegEx, R));

これは一般的な置換ツールであり、以下のようなパターンにマッチする文字列を置換して新しい文字列を作成する。 パターン reにマッチする文字列を input.他のオーバーロード に渡される。 に渡され、ユーザー定義のファンクタfun 。 に渡される。

このバージョンは input, を参照のこと。 replaceFirstで最初のマッチだけを置き換える。

Returns:

と同じ型の新しい文字列。 inputと同じ型の新しい文字列を返す。 fun の戻り値に置き換えられる。 を返す。 inputそのものを返す。

Parameters:

R input	検索する文字列
RegEx re	コンパイルされた正規表現
fun	使用するデリゲート

Examples:

string baz(Captures!(string) m)
{
    import std.string : toUpper;
    return toUpper(m.hit);
}
// 'a'と'r'を大文字にする:
auto s = replaceAll!(baz)("Strap a rocket engine on a chicken.",
        regex("[ar]"));
writeln(s); // "StRAp A Rocket engine on A chicken."(鶏の上にロケットエンジンを載せる。)

@trusted void replaceAllInto(Sink, R, C, RegEx)(Sink sink, R input, RegEx re, const(C)[] format)
if (isOutputRange!(Sink, dchar) && isSomeString!R && is(C : dchar) && isRegexFor!(RegEx, R));

@trusted void replaceAllInto(alias fun, Sink, R, RegEx)(Sink sink, R input, RegEx re)
if (isOutputRange!(Sink, dchar) && isSomeString!R && isRegexFor!(RegEx, R));

のバリエーションだ。 replaceAllのバリエーションである。 に分割して出力する。 sink.特に これは、最終出力をインクリメンタルに効率的に構築することを可能にする。

と同様、2つのオーバーロードがある。 replaceAllと同様、2つのオーバーロードがある、 もう1つはユーザー定義のファンクターである。

Examples:

// カンマを千の区切り文字として50個の大きな数字にランダムに挿入する
import std.array, std.conv, std.random, std.range;
static re = regex(`(?<=\d)(?=(\d\d\d)+\b)`, "g");
auto sink = appender!(char [])();
enum ulong min = 10UL ^^ 10, max = 10UL ^^ 19;
foreach (i; 0 .. 50)
{
    sink.clear();
    replaceAllInto(sink, text(uniform(min, max)), re, ",");
    foreach (pos; iota(sink.data.length - 4, 0, -4))
        writeln(sink.data[pos]); // ','
}

R replace(alias scheme = match, R, C, RegEx)(R input, RegEx re, const(C)[] format)
if (isSomeString!R && isRegexFor!(RegEx, R));

R replace(alias fun, R, RegEx)(R input, RegEx re)
if (isSomeString!R && isRegexFor!(RegEx, R));

置換のための古いAPI、操作はパターンのフラグに依存する re. g "フラグを指定すると replaceAllと同じ動作をする。 と同じ動作をする。 replaceFirst.

この関数の使用は推奨されない。 replaceAll または replaceFirstを明示的に使用してほしい。

struct Splitter(Flag!"keepSeparators" keepSeparators = No.keepSeparators, Range, alias RegEx = Regex) if (isSomeString!Range && isRegexFor!(RegEx, Range));

Splitter!(keepSeparators, Range, RegEx) splitter(Flag!"keepSeparators" keepSeparators = No.keepSeparators, Range, RegEx)(Range r, RegEx pat)
if (is(BasicElementOf!Range : dchar) && isRegexFor!(RegEx, Range));

正規表現を使って文字列 rを分割する。 patを使って文字列を分割する。

Parameters:

keepSeparators	フラグを指定する。
Range r	分割する文字列
RegEx pat	分割するパターン

Returns:

文字列の遅延範囲

Examples:

import std.algorithm.comparison : equal;
auto s1 = ", abc, de,  fg, hi, ";
assert(equal(splitter(s1, regex(", *")),
    ["", "abc", "de", "fg", "hi", ""]));

Examples:

パターンで分割するが、マッチは結果の範囲内に留める

import std.algorithm.comparison : equal;
import std.typecons : Yes;

auto pattern = regex(`([\.,])`);

assert("2003.04.05"
    .splitter!(Yes.keepSeparators)(pattern)
    .equal(["2003", ".", "04", ".", "05"]));

assert(",1,2,3"
    .splitter!(Yes.keepSeparators)(pattern)
    .equal([",", "1", ",", "2", ",", "3"]));

@property Range front();

@property bool empty();

void popFront();

@property auto save();

前進レンジのプリミティブ。

@trusted String[] split(String, RegEx)(String input, RegEx rx)
if (isSomeString!String && isRegexFor!(RegEx, String));

のスライスを分割した配列を作成するsplitter のイージー・バージョンである。 input.

alias RegexException = std.regex.internal.ir.RegexException;

正規表現のコンパイル中にエラーが発生した場合にスローされる例外オブジェクト。

auto escaper(Range)(Range r);

をエスケープした文字列出力を遅延的に生成する範囲。 正規表現内で使用する。

Examples:

import std.algorithm.comparison;
import std.regex;
string s = `This is {unfriendly} to *regex*`;
assert(s.escaper.equal(`This is \{unfriendly\} to \*regex\*`));