Language library

lang.regexp

Module lang.regexp

find
findAll
findAllGroups
findGroups
fromString
fullMatchGroups
isFullMatch
matchAt
matchGroupsAt
replace
replaceAll
split

Span

Groups
RegExp
Replacement
ReplacerFunction

ballerina/lang.regexp

0.0.0

Module overview

The lang.regexp module corresponds to the regexp basic type.

Functions

find

Isolated Function
function find(RegExp re, string str, int startIndex) returns Span?

Returns the first match of a regular expression within a string.

Copy
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 str at which to start looking for a match
Return Type
  • Span? - a Span describing the match, or nil if no match was found

findAll

Isolated Function
function findAll(RegExp re, string str, int startIndex) returns Span[]

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.

Copy
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 str at which to start looking for matches
Return Type
  • Span[] - a list containing a Span for each match found

findAllGroups

Isolated Function
function findAllGroups(RegExp re, string str, int startIndex) returns Groups[]

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.

Copy
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 str at which to start looking for matches
Return Type
  • Groups[] - a list containing a Group for each match found

findGroups

Isolated Function
function findGroups(RegExp re, string str, int startIndex) returns Groups?

Returns the Groups for the first match of a regular expression within a string.

Copy
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 str at which to start looking for a match
Return Type
  • Groups? - a Groups list describing the match, or nil if no match was found

fromString

Isolated Function
function fromString(string str) returns RegExp|error

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.

Copy
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
Return Type
  • RegExp|error - the regular expression, or an error value if str is not a valid regular expression

fullMatchGroups

Isolated Function
function fullMatchGroups(RegExp re, string str) returns Groups?

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.

Copy
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 Groups list describing the match, or nil if there is not a full match; the first Span in the list will be all of str

isFullMatch

Isolated Function
function isFullMatch(RegExp re, string str) returns boolean

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.

Copy
string:RegExp r = re `A|Th.*ch|^`;
r.isFullMatch("This is a Match") ⇒ true
r.isFullMatch("Not a complete Match") ⇒ false
Parameters
  • re RegExp - the regular expression
Return Type
  • boolean - true if there is full match of re with str, and false otherwise

matchAt

Isolated Function
function matchAt(RegExp re, string str, int startIndex) returns Span?

Tests whether there is a match of a regular expression at a specific index in the string.

Copy
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 str at which to look for a match; defaults to zero
Return Type
  • Span? - a Span describing the match, or nil if re did not match at that index; the startIndex of the Span will always be equal to startIndex

matchGroupsAt

Isolated Function
function matchGroupsAt(RegExp re, string str, int startIndex) returns Groups?

Returns the Groups of the match of a regular expression at a specific index in the string.

Copy
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 str at which to look for a match; defaults to zero
Return Type
  • Groups? - a Groups list describing the match, or nil if re did not match at that index; the startIndex of the first Span in the list will always be equal to the startIndex of the first member of the list

replace

Isolated Function
function replace(RegExp re, string str, Replacement replacement, int startIndex) returns string

Replaces the first match of a regular expression.

Copy
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 Replacement that gives the replacement for the match
  • startIndex int (default 0) - the index within str at which to start looking for a match; defaults to zero
Return Type
  • string - str with the first match, if any, replaced by the string specified by replacement

replaceAll

Isolated Function
function replaceAll(RegExp re, string str, Replacement replacement, int startIndex) 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.

Copy
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 Replacement that gives the replacement for each match
  • startIndex int (default 0) - the index within str at which to start looking for matches; defaults to zero
Return Type
  • string - str with every match replaced by the string specified by replacement

split

Isolated Function
function split(RegExp re, string str) returns string[]

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.

Copy
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 str separated by matches of re

Object types

lang.regexp: Span

Read Only

A span of a string. A span is a substring of another string.

substring

Isolated Function
function substring() returns string

Returns 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.

Types

lang.regexp: Groups

readonly & [Span, Span?...]

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.

lang.regexp: RegExp

any

The type RegExp refers to the tagged data basic type with tag re.

lang.regexp: Replacement

ReplacerFunction|string

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.

lang.regexp: ReplacerFunction

function(Groups) returns (string)

A function that constructs the replacement for the match of a regular expression. The groups parameter describes the match for which the replacement is to be constructed.

Terms of service

Privacy policy

Cookie policy

© 2018-2023 WSO2 LLC