Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page.
Requires a signed-in GitHub account. This works well for small changes.
If you'd like to make larger changes you may want to consider using
a local clone.
std.regex
Regular expressions
are a commonly used method of pattern matching
on strings, with regex being a catchy word for a pattern in this domain
specific language. Typical problems usually solved by regular expressions
include validation of user input and the ubiquitous find & replace
in text processing utilities.
Category | Functions |
---|---|
Matching | bmatch match matchAll matchFirst |
Building | ctRegex escaper regex |
Replace | replace replaceAll replaceAllInto replaceFirst replaceFirstInto |
Split | split splitter |
Objects | Captures Regex RegexException RegexMatch Splitter StaticRegex |
Synopsis
import std.regex; import std.stdio; void main() { // Print out all possible dd/mm/yy(yy) dates found in user input. 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() returns a range that can be iterated // to get all subsequent matches. foreach (c; matchAll(line, r)) writeln(c.hit); } } ... // Create a static regex at compile-time, which contains fast native code. auto ctr = ctRegex!(`^.*/([^/]+)/?$`); // It works just like a normal regex: auto c2 = matchFirst("foo/bar", ctr); // First match found here, if any assert(!c2.empty); // Be sure to check if there is a match before examining contents! assert(c2[1] == "bar"); // Captures is a range of submatches: 0 = full match. ... // multi-pattern 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[1] == "12"); ... // The result of the `matchAll/matchFirst` is directly testable with if/assert/while. // e.g. test if a string consists of letters: assert(matchFirst("Letter", `^\p{L}+$`));
Syntax and general information
The general usage guideline is to keep regex complexity on the side of simplicity, as its capabilities reside in purely character-level manipulation. As such it's ill-suited for tasks involving higher level invariants like matching an integer number bounded in an [a,b] interval. Checks of this sort of are better addressed by additional post-processing. The basic syntax shouldn't surprise experienced users of regular expressions. For an introduction to std.regex
see a
short tour of the module API
and its abilities.
There are other web resources on regular expressions to help newcomers,
and a good reference with tutorial
can easily be found.
This library uses a remarkably common ECMAScript syntax flavor
with the following extensions:
- Named subexpressions, with Python syntax.
- Unicode properties such as Scripts, Blocks and common binary properties e.g Alphabetic, White_Space, Hex_Digit etc.
- Arbitrary length and complexity lookbehind, including lookahead in lookbehind and vise-versa.
Pattern syntax
std.regex operates on codepoint level,
'character' in this table denotes a single Unicode codepoint.
Pattern element | Semantics |
Atoms | Match single characters |
any character except [{|*+?()^$ | Matches the character itself. |
. | In single line mode matches any character. Otherwise it matches any character except '\n' and '\r'. |
[class] | Matches a single character that belongs to this character class. |
[^class] | Matches a single character that does not belong to this character class. |
\cC | Matches the control character corresponding to letter C |
\xXX | Matches a character with hexadecimal value of XX. |
\uXXXX | Matches a character with hexadecimal value of XXXX. |
\U00YYYYYY | Matches a character with hexadecimal value of YYYYYY. |
\f | Matches a formfeed character. |
\n | Matches a linefeed character. |
\r | Matches a carriage return character. |
\t | Matches a tab character. |
\v | Matches a vertical tab character. |
\d | Matches any Unicode digit. |
\D | Matches any character except Unicode digits. |
\w | Matches any word character (note: this includes numbers). |
\W | Matches any non-word character. |
\s | Matches whitespace, same as \p{White_Space}. |
\S | Matches any character except those recognized as \s . |
\\ | Matches \ character. |
\c where c is one of [|*+?() | Matches the character c itself. |
\p{PropertyName} | Matches a character that belongs to the Unicode PropertyName set. Single letter abbreviations can be used without surrounding {,}. |
\P{PropertyName} | Matches a character that does not belong to the Unicode PropertyName set. Single letter abbreviations can be used without surrounding {,}. |
\p{InBasicLatin} | Matches any character that is part of the BasicLatin Unicode block. |
\P{InBasicLatin} | Matches any character except ones in the BasicLatin Unicode block. |
\p{Cyrillic} | Matches any character that is part of Cyrillic script. |
\P{Cyrillic} | Matches any character except ones in Cyrillic script. |
Quantifiers | Specify repetition of other elements |
* | Matches previous character/subexpression 0 or more times. Greedy version - tries as many times as possible. |
*? | Matches previous character/subexpression 0 or more times. Lazy version - stops as early as possible. |
+ | Matches previous character/subexpression 1 or more times. Greedy version - tries as many times as possible. |
+? | Matches previous character/subexpression 1 or more times. Lazy version - stops as early as possible. |
{n} | Matches previous character/subexpression exactly n times. |
{n,} | Matches previous character/subexpression n times or more. Greedy version - tries as many times as possible. |
{n,}? | Matches previous character/subexpression n times or more. Lazy version - stops as early as possible. |
{n,m} | Matches previous character/subexpression n to m times. Greedy version - tries as many times as possible, but no more than m times. |
{n,m}? | Matches previous character/subexpression n to m times. Lazy version - stops as early as possible, but no less then n times. |
Other | Subexpressions & alternations |
(regex) | Matches subexpression regex, saving matched portion of text for later retrieval. |
(?#comment) | An inline comment that is ignored while matching. |
(?:regex) | Matches subexpression regex, not saving matched portion of text. Useful to speed up matching. |
A|B | Matches subexpression A, or failing that, matches B. |
(?P<name>regex) | Matches named subexpression regex labeling it with name 'name'. When referring to a matched portion of text, names work like aliases in addition to direct numbers. |
Assertions | Match position rather than character |
^ | Matches at the begining of input or line (in multiline mode). |
$ | Matches at the end of input or line (in multiline mode). |
\b | Matches at word boundary. |
\B | Matches when not at word boundary. |
(?=regex) | Zero-width lookahead assertion. Matches at a point where the subexpression regex could be matched starting from the current position. |
(?!regex) | Zero-width negative lookahead assertion. Matches at a point where the subexpression regex could not be matched starting from the current position. |
(?<=regex) | Zero-width lookbehind assertion. Matches at a point where the subexpression regex could be matched ending at the current position (matching goes backwards). |
(?<!regex) | Zero-width negative lookbehind assertion. Matches at a point where the subexpression regex could not be matched ending at the current position (matching goes backwards). |
Character classes
Pattern element | Semantics |
Any atom | Has the same meaning as outside of a character class, except for ] which must be written as \] |
a-z | Includes characters a, b, c, ..., z. |
[a||b], [a--b], [a~~b], [a&&b] | Where a, b are arbitrary classes, means union, set difference, symmetric set difference, and intersection respectively. Any sequence of character class elements implicitly forms a union. |
Regex flags
Flag | Semantics |
g | Global regex, repeat over the whole input. |
i | Case insensitive matching. |
m | Multi-line mode, match ^, $ on start and end line separators as well as start and end of input. |
s | Single-line mode, makes . match '\n' and '\r' as well. |
x | Free-form syntax, ignores whitespace in pattern, useful for formatting complex regular expressions. |
Unicode support
This library provides full Level 1 support* according to UTS 18. Specifically:- 1.1 Hex notation via any of \uxxxx, \U00YYYYYY, \xZZ.
- 1.2 Unicode properties.
- 1.3 Character classes with set operations.
- 1.4 Word boundaries use the full set of "word" characters.
- 1.5 Using simple casefolding to match case insensitively across the full range of codepoints.
- 1.6 Respecting line breaks as any of \u000A | \u000B | \u000C | \u000D | \u0085 | \u2028 | \u2029 | \u000D\u000A.
- 1.7 Operating on codepoint level.
Replace format string
A set of functions in this module that do the substitution rely on a simple format to guide the process. In particular the table below applies to the format argument of replaceFirst and replaceAll. The format string can reference parts of match using the following notation.Format specifier | Replaced by |
$& | the whole match. |
$` | part of input preceding the match. |
$' | part of input following the match. |
$$ | '$' character. |
\c , where c is any character | the character c itself. |
\\ | '\' character. |
$1 .. $99 | submatch number 1 to 99 respectively. |
Slicing and zero memory allocations orientation
All matches returned by pattern matching functionality in this library are slices of the original input. The notable exception is the replace family of functions that generate a new string from the input. In cases where producing the replacement is the ultimate goal replaceFirstInto and replaceAllInto could come in handy as functions that avoid allocations even for replacement.License:
Authors:
Dmitry Olshansky,
API and utility constructs are modeled after the original std.
regex
by Walter Bright and Andrei Alexandrescu.
Source std/regex/package.d
- template
Regex
(Char) Regex
object holds regular expression pattern in compiled form.Instances of this object are constructed via calls to regex. This is an intended form for caching and storage of frequently used regular expressions.Example Test if this object doesn't contain any compiled pattern.
Regex!char r; assert(r.empty); r = regex(""); // Note: "" is a valid regex pattern. assert(!r.empty);
Getting a range of all the named captures in the regex.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
is Regex object that contains D code specially generated at compile-time to speed up matching.No longer used, kept as alias to Regex for backwards compatibility. - @trusted auto
regex
(S : C[], C)(const S[]patterns
, const(char)[]flags
= "")
if (isSomeString!S);
@trusted autoregex
(S)(Spattern
, const(char)[]flags
= "")
if (isSomeString!S); - Compile regular expression pattern for the later execution.Returns:Regex object that works on inputs having the same character width as
pattern
.Parameters:S pattern
A single regular expression to match. S[] patterns
An array of regular expression strings. The resulting Regex object will match any expression; use whichPattern to know which. const(char)[] flags
The attributes (g, i, m, s and x accepted) Throws:RegexException if there were any errors during compilation.Examples:void test(S)() { // multi-pattern regex example S[] arr = [`([a-z]+):(\d+)`, `(\d+),\d+`]; auto multi = regex(arr); // multi regex 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)) // Test with const array of patterns - see 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, alias flags = []); - Compile regular expression using CTFE and generate optimized native machine code for matching it.Returns:StaticRegex object for faster matching.Parameters:
pattern Regular expression flags The attributes (g, i, m, s and x accepted) - struct
Captures
(R) if (isSomeString!R); Captures
object contains submatches captured during a call to match or iteration over RegexMatch range.First element of range is the whole match.Examples:import std.range.primitives : popFrontN; auto c = matchFirst("@abc#", regex(`(\w)(\w)(\w)`)); assert(c.pre == "@"); // Part of input preceding match assert(c.post == "#"); // Immediately after match assert(c.hit == c[0] && c.hit == "abc"); // The whole match 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")); // Captures that are not matched will be null. c = matchFirst("ac", regex(`a(b)?c`)); assert(c); assert(!c[1]);
- @property R
pre
(); - Slice of input prior to the match.
- @property R
post
(); - Slice of input immediately after the match.
- @property R
hit
(); - Slice of matched portion of input.
- @property R
front
();
@property Rback
();
voidpopFront
();
voidpopBack
();
const @property boolempty
();
inout inout(R)opIndex
()(size_ti
); - Range interface.
- const nothrow @safe bool
opCast
(T : bool)(); - Explicit cast to bool. Useful as a shorthand for !(x.empty) in if and assert statements.
import std.regex; assert(!matchFirst("nothing", "something"));
- const nothrow @property @safe int
whichPattern
(); - Number of pattern matched counting, where 1 - the first pattern. Returns 0 on no match.Examples:
import std.regex; writeln(matchFirst("abc", "[0-9]+", "[a-z]+").whichPattern); // 2
- R
opIndex
(String)(Stringi
)
if (isSomeString!String); - Lookup named submatch.
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); //named groups are unaffected by range primitives assert(c["var"] =="a"); assert(c.front == "42");
- const @property size_t
length
(); - Number of matches in this object.
- @property ref auto
captures
(); - A hook for compatibility with original std.regex.
- struct
RegexMatch
(R) if (isSomeString!R); - A regex engine state, as returned by match family of functions.Effectively it's a forward range of Captures!R, produced by lazily searching for matches in a given input.
- @property R
pre
();
@property Rpost
();
@property Rhit
(); - Shorthands for front.pre, front.post, front.hit.
- inout @property inout(Captures!R)
front
();
voidpopFront
();
autosave
(); - Functionality for processing subsequent matches of global regexes via range interface:
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
(); - Test if this match object is empty.
- T
opCast
(T : bool)(); - Same as !(x.empty), provided for its convenience in conditional statements.
- inout @property inout(Captures!R)
captures
(); - Same as .front, provided for compatibility with original std.regex.
- auto
match
(R, RegEx)(Rinput
, RegExre
)
if (isSomeString!R && isRegexFor!(RegEx, R));
automatch
(R, String)(Rinput
, Stringre
)
if (isSomeString!R && isSomeString!String); - Start matching
input
to regex patternre
, using Thompson NFA matching scheme.The use of this function is discouraged - use either of matchAll or matchFirst. Delegating the kind of operation to "g" flag is soon to be phased out along with the ability to choose the exact matching scheme. The choice of matching scheme to use depends highly on the pattern kind and can done automatically on case by case basis.Returns:a RegexMatch object holding engine state after first match. - auto
matchFirst
(R, RegEx)(Rinput
, RegExre
)
if (isSomeString!R && isRegexFor!(RegEx, R));
automatchFirst
(R, String)(Rinput
, Stringre
)
if (isSomeString!R && isSomeString!String);
automatchFirst
(R, String)(Rinput
, String[]re
...)
if (isSomeString!R && isSomeString!String); - Find the first (leftmost) slice of the
input
that matches the patternre
. This function picks the most suitable regular expression engine depending on the pattern properties.re
parameter can be one of three types:- Plain string(s), in which case it's compiled to bytecode before matching.
- Regex!char (wchar/dchar) that contains a pattern in the form of compiled bytecode.
- StaticRegex!char (wchar/dchar) that contains a pattern in the form of compiled native machine code.
- auto
matchAll
(R, RegEx)(Rinput
, RegExre
)
if (isSomeString!R && isRegexFor!(RegEx, R));
automatchAll
(R, String)(Rinput
, Stringre
)
if (isSomeString!R && isSomeString!String);
automatchAll
(R, String)(Rinput
, String[]re
...)
if (isSomeString!R && isSomeString!String); - Initiate a search for all non-overlapping matches to the pattern
re
in the giveninput
. The result is a lazy range of matches generated as they are encountered in the input going left to right.This function picks the most suitable regular expression engine depending on the pattern properties.re
parameter can be one of three types:- Plain string(s), in which case it's compiled to bytecode before matching.
- Regex!char (wchar/dchar) that contains a pattern in the form of compiled bytecode.
- StaticRegex!char (wchar/dchar) that contains a pattern in the form of compiled native machine code.
Returns:RegexMatch object that represents matcher state after the first match was found or an empty one if not present. - auto
bmatch
(R, RegEx)(Rinput
, RegExre
)
if (isSomeString!R && isRegexFor!(RegEx, R));
autobmatch
(R, String)(Rinput
, Stringre
)
if (isSomeString!R && isSomeString!String); - The use of this function is discouraged - use either of matchAll or matchFirst. Delegating the kind of operation to "g" flag is soon to be phased out along with the ability to choose the exact matching scheme. The choice of matching scheme to use depends highly on the pattern kind and can done automatically on case by case basis.Returns:a RegexMatch object holding engine state after first match.
- R
replaceFirst
(R, C, RegEx)(Rinput
, RegExre
, const(C)[]format
)
if (isSomeString!R && is(C : dchar) && isRegexFor!(RegEx, R)); - Construct a new string from
input
by replacing the first match with a string generated from it according to theformat
specifier.To replace all matches use replaceAll.Parameters:R input
string to search RegEx re
compiled regular expression to use const(C)[] format
format string to generate replacements from, see the format string. Returns:A string of the same type with the first match (if any) replaced. If no match is found returns the input string itself.Examples:writeln(replaceFirst("noon", regex("n"), "[$&]")); // "[n]oon"
- R
replaceFirst
(alias fun, R, RegEx)(Rinput
, RegExre
)
if (isSomeString!R && isRegexFor!(RegEx, R)); - This is a general replacement tool that construct a new string by replacing matches of pattern
re
in theinput
. Unlike the other overload there is no format string instead captures are passed to to a user-defined functor fun that returns a new string to use as replacement.This version replaces the first match ininput
, see replaceAll to replace the all of the matches.Returns:A new string of the same type asinput
with all matches replaced by return values of fun. If no matches found returns theinput
itself.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 Sinksink
, Rinput
, RegExre
, const(C)[]format
)
if (isOutputRange!(Sink, dchar) && isSomeString!R && is(C : dchar) && isRegexFor!(RegEx, R));
@trusted voidreplaceFirstInto
(alias fun, Sink, R, RegEx)(Sinksink
, Rinput
, RegExre
)
if (isOutputRange!(Sink, dchar) && isSomeString!R && isRegexFor!(RegEx, R)); - A variation on replaceFirst that instead of allocating a new string on each call outputs the result piece-wise to the
sink
. In particular this enables efficient construction of a final output incrementally.Like in replaceFirst family of functions there is an overload for the substitution guided by theformat
string and the one with the user defined callback.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"); //equivalent of the above with user-defined callback replaceFirstInto!(cap=>cap[1])(result, m2, regex(`([a-z]+) message`)); writeln(result.data); // "first\nsecond\n"
- @trusted R
replaceAll
(R, C, RegEx)(Rinput
, RegExre
, const(C)[]format
)
if (isSomeString!R && is(C : dchar) && isRegexFor!(RegEx, R)); - Construct a new string from
input
by replacing all of the fragments that match a patternre
with a string generated from the match according to theformat
specifier.To replace only the first match use replaceFirst.Parameters:R input
string to search RegEx re
compiled regular expression to use const(C)[] format
format string to generate replacements from, see the format string. Returns:A string of the same type asinput
with the all of the matches (if any) replaced. If no match is found returns the input string itself.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)(Rinput
, RegExre
)
if (isSomeString!R && isRegexFor!(RegEx, R)); - This is a general replacement tool that construct a new string by replacing matches of pattern
re
in theinput
. Unlike the other overload there is no format string instead captures are passed to to a user-defined functor fun that returns a new string to use as replacement.This version replaces all of the matches found ininput
, see replaceFirst to replace the first match only.Returns:A new string of the same type asinput
with all matches replaced by return values of fun. If no matches found returns theinput
itself.Parameters:R input
string to search RegEx re
compiled regular expression fun delegate to use Examples:string baz(Captures!(string) m) { import std.string : toUpper; return toUpper(m.hit); } // Capitalize the letters 'a' and '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)(Sinksink
, Rinput
, RegExre
, const(C)[]format
)
if (isOutputRange!(Sink, dchar) && isSomeString!R && is(C : dchar) && isRegexFor!(RegEx, R));
@trusted voidreplaceAllInto
(alias fun, Sink, R, RegEx)(Sinksink
, Rinput
, RegExre
)
if (isOutputRange!(Sink, dchar) && isSomeString!R && isRegexFor!(RegEx, R)); - A variation on replaceAll that instead of allocating a new string on each call outputs the result piece-wise to the
sink
. In particular this enables efficient construction of a final output incrementally.As with replaceAll there are 2 overloads - one with a format string, the other one with a user defined functor.Examples:// insert comma as thousands delimiter in fifty randomly produced big numbers 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)(Rinput
, RegExre
, const(C)[]format
)
if (isSomeString!R && isRegexFor!(RegEx, R));
Rreplace
(alias fun, R, RegEx)(Rinput
, RegExre
)
if (isSomeString!R && isRegexFor!(RegEx, R)); - Old API for replacement, operation depends on flags of pattern
re
. With "g" flag it performs the equivalent of replaceAll otherwise it works the same as 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)(Ranger
, RegExpat
)
if (is(BasicElementOf!Range : dchar) && isRegexFor!(RegEx, Range)); - Splits a string
r
using a regular expressionpat
as a separator.Parameters:keepSeparators flag to specify if the matches should be in the resulting range Range r
the string to split RegEx pat
the pattern to split on Returns:A lazy range of stringsExamples:import std.algorithm.comparison : equal; auto s1 = ", abc, de, fg, hi, "; assert(equal(splitter(s1, regex(", *")), ["", "abc", "de", "fg", "hi", ""]));
Examples:Split on a pattern, but keep the matches in the resulting rangeimport 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 boolempty
();
voidpopFront
();
@property autosave
(); - Forward range primitives.
- @trusted String[]
split
(String, RegEx)(Stringinput
, RegExrx
)
if (isSomeString!String && isRegexFor!(RegEx, String)); - An eager version of splitter that creates an array with splitted slices of
input
. - alias
RegexException
= std.regex.internal.ir.RegexException
; - Exception object thrown in case of errors during regex compilation.
- auto
escaper
(Range)(Ranger
); - A range that lazily produces a string output escaped to be used inside of a regular expression.Examples:
import std.algorithm.comparison; import std.regex; string s = `This is {unfriendly} to *regex*`; assert(s.escaper.equal(`This is \{unfriendly\} to \*regex\*`));
Copyright © 1999-2022 by the D Language Foundation | Page generated by
Ddoc on (no date time)