Module lang.regexp
ballerina/lang.regexp Ballerina library
Module overview
The lang.regexp module corresponds to the regexp basic type.
Functions
find
Returns the first match of a regular expression within a string.
string:RegExp r = re `World`; r.find("Not A Match") is () ⇒ true r.find("Hello World") is regexp:Span ⇒ true r.find("Hello World", 6) is regexp:Span ⇒ true
Parameters
- re RegExp - the regular expression
- str string - the string in which to look for a match of
re
- startIndex int (default 0) - the index within
strat which to start looking for a match
Return Type
- Span? - a
Spandescribing the match, or nil if no match was found
findAll
Returns a list of all the matches of a regular expression within a string. After one match is found, it looks for the next match starting where the previous match ended, so the list of matches will be non-overlapping.
string:RegExp r = re `[bB].tt[a-z]*`; r.findAll("Not A Match").length() ⇒ 0 r.findAll("Butter was bought by Betty but the butter was bitter.").length() ⇒ 4 r.findAll("Butter was bought by Betty but the butter was bitter.", 7).length() ⇒ 3
Parameters
- re RegExp - the regular expression
- str string - the string in which to look for matches of
re
- startIndex int (default 0) - the index within
strat which to start looking for matches
Return Type
- Span[] - a list containing a
Spanfor each match found
findAllGroups
Returns the Groups of all the matches of a regular expression within a string.
After one match is found, it looks for the next match starting where the previous
match ended, so the list of matches will be non-overlapping.
string:RegExp r = re `(([a-z]u)(bble))`; r.findAllGroups("Not A Match").length() ⇒ 0 r.findAllGroups("rubble, trouble, bubble, hubble").length() ⇒ 3 r.findAllGroups("rubble, trouble, bubble, hubble", 7).length() ⇒ 2
Parameters
- re RegExp - the regular expression
- str string - the string in which to look for matches of
re
- startIndex int (default 0) - the index within
strat which to start looking for matches
Return Type
- Groups[] - a list containing a
Groupfor each match found
findGroups
Returns the Groups for the first match of a regular expression within a string.
string:RegExp r = re `([bB].tt[a-z]*)`; r.findGroups("Not A Match") is () ⇒ true r.findGroups("Butter was bought by Betty but the butter was bitter.") is regexp:Groups ⇒ true r.findGroups("Butter was bought by Betty but the butter was bitter.", 7) is regexp:Groups ⇒ true
Parameters
- re RegExp - the regular expression
- str string - the string in which to look for a match of
re
- startIndex int (default 0) - the index within
strat which to start looking for a match
Return Type
- Groups? - a
Groupslist describing the match, or nil if no match was found
fromString
Constructs a regular expression from a string.
The syntax of the regular expression is the same as accepted by the re tagged data template expression.
regexp:fromString("AB+C*D{1,4}") ⇒ re `AB+C*D{1,4}` regexp:fromString("AB+^*") ⇒ error
Parameters
- str string - the string representation of a regular expression
fullMatchGroups
Returns the Groups of the match of a regular expression that is a full match of a string.
A match of the regular expression in a string is a full match if it
starts at index 0 and ends at index n, where n is the length of the string.
string:RegExp r = re `([0-9]+)×([0-9]+)`; r.fullMatchGroups("test: 1440×900") is () ⇒ true r.fullMatchGroups("1440×900") is regexp:Groups ⇒ true
Parameters
- re RegExp - the regular expression
- str string - the string in which to look for a match of
re
Return Type
- Groups? - a
Groupslist describing the match, or nil if there is not a full match; the firstSpanin the list will be all ofstr
isFullMatch
Tests whether there is full match of regular expression with a string.
A match of a regular expression in a string is a full match if it
starts at index 0 and ends at index n, where n is the length of the string.
string:RegExp r = re `A|Th.*ch|^`; r.isFullMatch("This is a Match") ⇒ true r.isFullMatch("Not a complete Match") ⇒ false
Return Type
- boolean - true if there is full match of
rewithstr, and false otherwise
matchAt
Tests whether there is a match of a regular expression at a specific index in the string.
string:RegExp r = re `World`; r.matchAt("Hello World") is () ⇒ true r.matchAt("Hello World", 6) is regexp:Span ⇒ true
Parameters
- re RegExp - the regular expression
- str string - the string in which to look for a match of
re
- startIndex int (default 0) - the index within
strat which to look for a match; defaults to zero
Return Type
- Span? - a
Spandescribing the match, or nil ifredid not match at that index; the startIndex of theSpanwill always be equal tostartIndex
matchGroupsAt
Returns the Groups of the match of a regular expression at a specific index in the string.
string:RegExp r = re `([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])?`; r.matchGroupsAt("time: 14:35:59") is () ⇒ true r.matchGroupsAt("time: 14:35:59", 6) is regexp:Groups ⇒ true
Parameters
- re RegExp - the regular expression
- str string - the string in which to look for a match of
re
- startIndex int (default 0) - the index within
strat which to look for a match; defaults to zero
Return Type
- Groups? - a
Groupslist describing the match, or nil ifredid not match at that index; the startIndex of the firstSpanin the list will always be equal to thestartIndexof the first member of the list
replace
function replace(RegExp re, string str, Replacement replacement, int startIndex) returns stringReplaces the first match of a regular expression.
string:RegExp r = re `0+`; r.replace("10010011", "*") ⇒ 1*10011 r.replace("10010011", "*", 4) ⇒ 1001*11 r.replace("122111", "*") ⇒ 122111 r.replace("10010011", replaceFunction) ⇒ 1*10011 r.replace("10010011", replaceFunction, 4) ⇒ 1001*11 isolated function replaceFunction(regexp:Groups groups) returns string => "*";
Parameters
- re RegExp - the regular expression
- str string - the string in which to perform the replacements
- replacement Replacement - a
Replacementthat gives the replacement for the match
- startIndex int (default 0) - the index within
strat which to start looking for a match; defaults to zero
Return Type
- string -
strwith the first match, if any, replaced by the string specified byreplacement
replaceAll
function replaceAll(RegExp re, string str, Replacement replacement, int startIndex) returns stringReplaces all matches of a regular expression. After one match is found, it looks for the next match starting where the previous match ended, so the matches will be non-overlapping.
string:RegExp r = re `0+`; r.replaceAll("10010011", "*") ⇒ 1*1*11 r.replaceAll("10010011", "*", 4) ⇒ 1001*11 r.replaceAll("122111", "*") ⇒ 122111 r.replaceAll("10010011", replaceFunction) ⇒ 121211 r.replaceAll("10010011", replaceFunction, 4) ⇒ 1001211 isolated function replaceFunction(regexp:Groups groups) returns string => groups[0].substring().length().toString();
Parameters
- re RegExp - the regular expression
- str string - the string in which to perform the replacements
- replacement Replacement - a
Replacementthat gives the replacement for each match
- startIndex int (default 0) - the index within
strat which to start looking for matches; defaults to zero
Return Type
- string -
strwith every match replaced by the string specified byreplacement
split
Splits a string into substrings separated by matches of a regular expression.
This finds the the non-overlapping matches of a regular expression and
returns a list of substrings of str that occur before the first match,
between matches, or after the last match. If there are no matches, then
[str] will be returned.
string:RegExp r = re `,`; r.split("abc,cde,efg") ⇒ ["abc","cde","efg"] r.split("abc cde efg") ⇒ ["abc cde efg"]
Parameters
- re RegExp - the regular expression that specifies the separator
- str string - the string to be split
Return Type
- string[] - a list of substrings of
strseparated by matches ofre
Object types
lang.regexp: Span
A span of a string. A span is a substring of another string.
substring
function substring() returns stringReturns a string with the content of the span.
Fields
- startIndex int - The index within the string where the span starts.
- endIndex int - The index within the string following the end of the span.
The length of the span is
endIndex - startIndex.
Union types
lang.regexp: Replacement
Replacement
The replacement for the match of a regular expression found within a string. A string value specifies that the replacement is a fixed string. A function that specifies that the replacement is constructed by calling a function for each match.
Intersection types
lang.regexp: Groups
Groups
A list providing detailed information about the match of a regular expression within string.
Each member of the list identifies the Span within the string matched
by each of the regular expression's capturing groups.
The member with index 0 corresponds to the entire regular expression.
The group with index i, where i > 1,is the i-th capturing group;
this will be nil if the match of the regular expression did not use
a match of the capturing group.
The capturing groups within a regular expression are ordered by the position
of their opening parenthesis.
Function types
Any types
lang.regexp: RegExp
RegExp
The type RegExp refers to the tagged data basic type with tag re.