ballerina/lang.regexp Ballerina library

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

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

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

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

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

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

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

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

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

Replaces 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 => "*";

Replaces 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();

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"]