## Overview

This module provides APIs for searching, splitting, and replacing the set of characters of a string. These APIs are using a 
regular expression as a `String` to perform these operations by finding the string matches.

[Regular expressions](https://en.wikipedia.org/wiki/Regular_expression), are notations for describing sets of 
character strings. If a particular string is in the set described by a regular expression, the regular expression matches that string.

For information on the operations, which you can perform with the regex module, see the below **Functions**.


Checks whether the given string matches the provided regex.
Note that `\\` is used as for escape sequence and `\\\\` is used to inserts a backslash
character in the string or regular expression.
```ballerina
boolean isMatched = regex:matches("Ballerina is great", "Ba[a-z ]+");
```



matches

stringToMatch

string

regex

`true` if the provided string matches the regex or else `false`


boolean

Replaces the first substring that matches the given regex with
the provided replacement string or string returned by the provided function.
Note that `\\` is used as for escape sequence and `\\\\` is used to inserts a backslash
character in the string or regular expression.
```ballerina
string result = regex:replace("Ballerina is great", "\\s+", "_");
```



replace

The original string to replace the first occurrence of the
substring that matches the provided regex


originalString

The regex to match the first substring in the `originalString` to be replaced


The replacement string or a function to be invoked to create the new substring to be
used to replace the first match to the given regex


replacement

Replacement

startIndex

The resultant string with the replaced substring


Replaces each occurrence of the substrings, which match the provided
regex from the given original string value with the provided replacement string.
Note that `\\` is used as for escape sequence and `\\\\` is used to inserts a backslash
character in the string or regular expression.
```ballerina
string result = regex:replaceAll("Ballerina is great", "\\s+", "_");
```



replaceAll

The original string to replace the occurrences of the
substrings that match the provided regex


The regex to match the substrings in the `originalString` , which is to be replaced


The resultant string with the replaced substrings


Replaces the first substring that matches the given regex with
the provided replacement string.
Note that `\\` is used as for escape sequence and `\\\\` is used to inserts a backslash
character in the string or regular expression.
```ballerina
string result = regex:replaceFirst("Ballerina is great", "\\s+", "_");
```



replaceFirst

The regex to match the first substring in the `originalString` to
be replaced


The replacement string to replace the first substring, which
matches the regex


The resultant string with the replaced substring
# Deprecated
This function will be removed in a later. Use `replace` instead.


Returns the first substring in str that matches the regex.
Note that `\\` is used as for escape sequence and `\\\\` is used to inserts a backslash
character in the string or regular expression.
```ballerina
regex:Match? result = regex:search("Betty Botter bought some butter but she said the butter’s bitter.",
                                   "\\b[bB].tt[a-z]*");
```



search

a `Match` record which holds the matched substring, or nil if there is no match


Match

Returns all substrings in string that match the regex.
Note that `\\` is used as for escape sequence and `\\\\` is used to inserts a backslash
character in the string or regular expression.
```ballerina
regex:Match[] result = regex:searchAll("Betty Botter bought some butter but she said the butter’s bitter.",
                                     "\\b[bB].tt[a-z]*");
```



searchAll

Returns an array of strings by splitting a string using the provided
regex as the delimiter.
Note that `\\` is used as for escape sequence and `\\\\` is used to inserts a backslash
character in the string or regular expression.
```ballerina
string[] result = regex:split("Ballerina is great", " ");
```



split

receiver

The delimiter is a regex, which splits the given string


delimiter

An array of strings containing the individual strings that are split


Abstract object representation to hold information about matched regex groups.


Groups

Holds the results of a match against a regular expression. 
It contains the match boundaries, groups, and group boundaries.



matched

endIndex

groups

This module provides APIs for searching, splitting, and replacing the set of characters of a string. These APIs are using a 


A type to be used to get a replacement string.


Object type: Groups