For quick one-off matches, you can use the static call:

int matchstart, matchlength = -1;
Match matchResult = Regex.Match(subjectString, @"\d+");
if (matchResult.Success) {
    matchstart = matchResult.Index;
    matchlength = matchResult.Length;
}

To use the same regex repeatedly, construct a Regex object:

int matchstart, matchlength = -1;
Regex regexObj = new Regex(@"\d+");
Match matchResult = regexObj.Match(subjectString).Value;
if (matchResult.Success) {
    matchstart = matchResult.Index;
    matchlength = matchResult.Length;
}

For quick one-off matches, you can use the static call:

Dim MatchStart = -1
Dim MatchLength = -1
Dim MatchResult = Regex.Match(SubjectString, "\d+")
If MatchResult.Success Then
    MatchStart = MatchResult.Index
    MatchLength = MatchResult.Length
End If

To use the same regex repeatedly, construct a Regex object:

Dim MatchStart = -1
Dim MatchLength = -1
Dim RegexObj As New Regex("\d+")
Dim MatchResult = Regex.Match(SubjectString, "\d+")
If MatchResult.Success Then
    MatchStart = MatchResult.Index
    MatchLength = MatchResult.Length
End If

int matchStart, matchLength = -1;
Pattern regex = Pattern.compile("\\d+");
Matcher regexMatcher = regex.matcher(subjectString);
if (regexMatcher.find()) {
	matchStart = regexMatcher.start();
	matchLength = regexMatcher.end() - matchStart;
}

var matchstart = -1;
var matchlength = -1;
var match = /\d+/.exec(subject);
if (match) {
    matchstart = match.index;
    matchlength = match[0].length;
}

if (preg_match('/\d+/', $subject, $groups, PREG_OFFSET_CAPTURE)) {
    $matchstart = $groups[0][1];
    $matchlength = strlen($groups[0][0]);
}

if ($subject =~ m/\d+/g) {
    $matchstart = $-[0];
    $matchlength = $+[0] - $-[0];
}

For quick one-off matches, you can use the global function:

matchobj = re.search(r"\d+", subject)
if matchobj:
    matchstart = matchobj.start()
    matchlength = matchobj.end() - matchstart

To use the same regex repeatedly, use a compiled object:

reobj = re.compile(r"\d+")
matchobj = reobj.search(subject)
if matchobj:
    matchstart = matchobj.start()
    matchlength = matchobj.end() - matchstart

You can use the =~ operator and its magic $~ variable:

if subject =~ /regex pattern/
    matchstart = $~.begin()
    matchlength = $~.end() - matchstart
end

Alternatively, you can call the match method on a Regexp object:

matchobj = /regex pattern/.match(subject)
if matchobj
    matchstart = matchobj.begin()
    matchlength = matchobj.end() - matchstart
end

To get the match index and length, we use the same Regex.Match() method described in the previous recipe. This time, we use the Index and Length properties of the Match object returned by Regex.Match().

Index is the index in the subject string at which the regex match begins. If the regex match begins at the start of the string, Index will be zero. If the match starts at the second character in the string, Index will be one. The maximum value for Index is the length of the string. That can happen when the regex finds a zero-length match at the end of the string. For example, the regex consisting solely of the end-of-string anchor ‹\Z› always matches at the end of the string.

Length indicates the number of characters that were matched. It is possible for a valid match to be zero characters long. For example, the regex consisting only of the word boundary ‹\b› will find a zero-length match at the start of the first word in the string.

If the match attempt fails, Regex.Match() still returns a Match object. Its Index and Length properties will both be zero. These values can also happen with a successful match. The regex consisting of the start-of-string anchor ‹\A› will find a zero-length match at the start of the string. Thus, you cannot rely on Match.Index or Match.Length to indicate whether the match attempt was successful. Use Match.Success instead.

To get the position and length of the match, call Matcher.find() as described in the previous recipe. When find() returns true, call Matcher.start() without any parameters to obtain the index of the first character that is part of the regex match. Call end() without any parameters to get the index of the first character after the match. Subtract the start from the end to get the length of the match, which can be zero. If you call start() or end() without a prior call to find(), you’ll get an IllegalStateException.

Call the exec() method on a regexp object to get an array with details about the match. This array has a few additional properties. The index property stores the position in the subject string at which the regex match begins. If the match begins at the start of the string, index will be zero. Element zero in the array holds a string with the overall regex match. Get the length property of that string to determine the length of the match.

If the regular expression cannot match the string at all, regexp.exec() returns null.

Do not use the lastIndex property of the array returned by exec() to determine the ending position of the match. In a strict JavaScript implementation, the lastIndex does not exist in the returned array at all, but only in the regexp object itself. You shouldn’t use regexp.lastIndex either. It is unreliable, due to cross-browser differences (see Recipe 3.11 for more details). Instead, simply add up match.index and match[0].length to determine where the regex match ended.

The previous recipe explains how you can get the text matched by the regular expression by passing a third parameter to preg_match(). You can get the position of the match by passing the constant PREG_OFFSET_CAPTURE as a fourth parameter. This parameter changes what preg_match() stores in the third parameter when it returns 1.

When you either omit the fourth parameter or set it to zero, the variable passed as the third parameter receives an array of strings. When you pass PREG_OFFSET_CAPTURE as the fourth parameter, the variable receives an array of arrays. Element zero in the overall array is still the overall match (see the preceding recipe), and elements one and beyond are still capturing groups one and beyond (see the next recipe). But instead of holding a string with the text matched by the regex or a capturing group, the element holds an array with two values: the text that was matched and the position in the string at which it was matched.

To get the details of the overall match, subelement zero of element zero gives us the text matched by the regex. We pass this to the strlen() function to calculate its length. Subelement one of element zero holds an integer with the position in the subject string at which the match starts.

Perl stores the position where the match of each capturing group starts in the array @- and the position where each group ends in @-. The overall regex match is group number zero. You can get starting position of the overall match with $-[0] and the ending position with $+[0].

The start() method of MatchObject returns the position in the string at which the regular expression match begins. The end() method returns the position of the first character after the match. Both methods return the same value when a zero-length regular expression match is found.

You can pass a parameter to start() and end() to retrieve the range of text matched by one of the capturing groups in the regular expressions. Call start(1) for the first capturing group, end(2) for the second group, and so on. Python supports up to 99 capturing groups. Group number 0 is the overall regular expression match. Any number other than zero up to the number of capturing groups in the regular expression (with 99 being the ceiling) causes start() and end() to raise an IndexError exception. If the group number is valid but the group did not participate in the regex match, start() and end() both return -1 for that group.

If you want to store both the starting and ending positions in a tuple, call the span() method on the match object.

Recipe 3.5 uses the =~ operator to find the first regex match in a string. A side effect of this operator is that it fills the special $~ variable with an instance of the MatchData class. This variable is thread-local and method-local. That means you can use the contents of this variable until your method exits or until the next time you use the =~ operator in your method, without worrying that another thread or another method in your thread will overwrite it.

If you want to keep the details of multiple regex matches, call the match() method on a Regexp object. This method takes a subject string as its only parameter. It returns a MatchData instance when a match can be found, or nil otherwise. It also sets the $~ variable to the same MatchObject instance, but does not overwrite other MatchObject instances stored in other variables.

The MatchData object stores all the details about a regular expression match. Recipes 3.7 and 3.9 explain how to get the text matched by the regular expression and by capturing groups.

The begin() method returns the position in the subject string at which the regex match begins. end() returns the position of the first character after the regex match. offset() returns an array with the beginning and ending positions. These three methods take one parameter. Pass 0 to get the positions of the overall regex match, or pass a positive number to get the positions of the specified capturing group. For example, begin(1) returns the start of the first capturing group.

Do not use length() or size() to get the length of the match. Both these methods return the number of elements in the array that MatchData evaluates to in array context, as explained in Recipe 3.9.