/ 
SPVM-Regex-0.246
River stage one • 4 direct dependents • 4 total dependents
/ SPVM::Regex

Name

SPVM::Regex - Regular Expressions

Description

The Regex class of SPVM has methods for regular expressions.

Google RE2 is used as the regular expression library.

Usage

Re:

use Re;

my $string = "Hello World"
my $match = Re->m($string, "^Hellow");

# ABC de ABC
my $string_ref = ["abc de abc"];
Re->s($string_ref, ["abc", "g"], "ABC");

Regex:

use Regex;

# Pattern match
{
  my $re = Regex->new("ab*c");
  my $string = "zabcz";
  my $match = $re->match("zabcz");
}

# Pattern match - UTF-8
{
  my $re = Regex->new("あ+");
  my $string = "いあああい";
  my $match = $re->match($string);
}

# Pattern match - Character class and the nagation
{
  my $re = Regex->new("[A-Z]+[^A-Z]+");
  my $string = "ABCzab";
  my $match = $re->match($string);
}

# Pattern match with captures
{
  my $re = Regex->new("^(\w+) (\w+) (\w+)$");
  my $string = "abc1 abc2 abc3";
  my $match = $re->match($string);
  
  if ($match) {
    my $cap1 = $match->cap1;
    my $cap2 = $match->cap2;
    my $cpa3 = $match->cap3;
  }
}

# Replace
{
  my $re = Regex->new("abc");
  my $string = "ppzabcz";
  
  # "ppzABCz"
  my $result = $re->replace($string, "ABC");
}

# Replace with a callback and capture
{
  my $re = Regex->new("a(bc)");
  my $string = "ppzabcz";
  
  # "ppzABbcCz"
  my $result = $re->replace($string, method : string ($re : Regex, $match : Regex::Match) {
    return "AB" . $match->cap1 . "C";
  });
}

# Replace global
{
  my $re = Regex->new("abc");
  my $string = "ppzabczabcz";
  
  # "ppzABCzABCz"
  my $result = $re->replace_g($string, "ABC");
}

# Replace global with a callback and capture
{
  my $re = Regex->new("a(bc)");
  my $string = "ppzabczabcz";
  
  # "ppzABCbcPQRSzABCbcPQRSz"
  my $result = $re->replace_g($string, method : string ($re : Regex, $match : Regex::Match) {
    return "ABC" . $match->cap1 . "PQRS";
  });
}

# . - single line mode
{
  my $re = Regex->new("(.+)", "s");
  my $string = "abc\ndef";
  
  my $match = $re->match($string);
  
  unless ($match) {
    return 0;
  }
  
  unless ($match->cap1 eq "abc\ndef") {
    return 0;
  }
}

Details

More Perlish Pattern Match and Replacement

See Re class if you want to use more Perlish pattern match and replacement.

Dependent Resources

Regular Expression Syntax

Google RE2 Syntax

Fields

Class Methods

new

static method new : Regex ($pattern : string, $flags : string = undef)

Creates a new Regex object and compiles the regex pattern $pattern with the flags $flags, and retruns the created object.

my $re = Regex->new("^ab+c");
my $re = Regex->new("^ab+c", "s");

Instance Methods

match

method match : Regex::Match ($string : string, $offset : int = 0, $length : int = -1);

The alias for the following match_forward method.

my $ret = $self->match_forward($string, \$offset, $length);

match_forward

method match_forward : Regex::Match ($string : string, $offset_ref : int*, $length : int = -1);

Performs pattern matching on the substring from the offset $$offset_ref to the length $length of the string $string.

The $$offset_ref is updated to the next position.

If the pattern matching is successful, returns a Regex::Match object. Otherwise returns undef.

Exceptions:

The $string must be defined. Otherwise an exception is thrown.

The $offset + the $length must be less than or equal to the length of the $string. Otherwise an exception is thrown.

If the regex is not compiled, an exception is thrown.

replace

method replace  : string ($string : string, $replace : object of string|Regex::Replacer, $offset : int = 0, $length : int = -1, $options : object[] = undef)

The alias for the following replace_common method.

my $ret = $self->replace_common($string, $replace, \$offset, $length, $options);

replace_g

method replace_g  : string ($string : string, $replace : object of string|Regex::Replacer, $offset : int = 0, $length : int = -1, $options : object[] = undef)

The alias for the following replace_common method.

unless ($options) {
  $options = {};
}
$options = Fn->merge_options({global => 1}, $options);
return $self->replace_common($string, $replace, \$offset, $length, $options);

replace_common

method replace_common : string ($string : string, $replace : object of string|Regex::Replacer,
  $offset_ref : int*, $length : int = -1, $options : object[] = undef);

Replaces the substring from the offset $$offset_ref to the length $length of the string $string with the replacement string or callback $replace with the options $options.

If the $replace is a Regex::Replacer object, the return value of the callback is used for the replacement.

Options:

  • global

    This option must be a Int object. Otherwise an exception is thrown.

    If the value of the Int object is a true value, the global replacement is performed.

  • info

    This option must be an array of the Regex::ReplaceInfo object. Otherwise an exception is thrown.

    If this option is specifed, the first element of the array is set to a Regex::ReplaceInfo object of the replacement result.

Exceptions:

The $string must be defined. Otherwise an exception is thrown.

The $replace must be a string or a Regex::Replacer object. Otherwise an exception is thrown.

The $offset must be greater than or equal to 0. Otherwise an exception is thrown.

The $offset + the $length must be less than or equal to the length of the $string. Otherwise an exception is thrown.

Exceptions of the match_forward method can be thrown.

split

method split : string[] ($string : string, $limit : int = 0);

The same as the split method in the Fn class, but the regular expression is used as the separator.

buffer_match

method buffer_match : Regex::Match ($string_buffer : StringBuffer, $offset : int = 0, $length : int = -1);

The same as "match", but the first argument is a StringBuffer object, and the following excetpions are thrown.

Exceptions:

The $offset + $length must be less than or equalt to the lenght of the $string_buffer. Otherwise an exception is thrown.

buffer_match_forward

method buffer_match_forward : Regex::Match ($string_buffer : StringBuffer, $offset_ref : int*, $length : int = -1);

The same as "match_forward", but the first argument is a StringBuffer object, and the following excetpions are thrown.

Exceptions:

The $offset + $length must be less than or equalt to the lenght of the $string_buffer. Otherwise an exception is thrown.

buffer_replace

method buffer_replace  : void ($string_buffer : StringBuffer, $replace : object of string|Regex::Replacer, $offset : int = 0, $length : int = -1, $options : object[] = undef);

The same as "replace", but the first argument is a StringBuffer object, and the return type is void.

The replacement is performed on the string buffer.

buffer_replace_g

method buffer_replace_g  : string ($string_buffer : StringBuffer, $replace : object of string|Regex::Replacer, $offset : int = 0, $length : int = -1, $options : object[] = undef);

The same as "replace_g", but the first argument is a StringBuffer object, and the return type is void.

The replacement is performed on the string buffer.

buffer_replace_common

method buffer_replace_common : void ($string_buffer : StringBuffer, $replace : object of string|Regex::Replacer, $offset_ref : int*, $length : int = -1, $options : object[] = undef);

The same as "replace_common", but the first argument is a StringBuffer object, and the return type is void.

The replacement is performed on the string buffer.

Repository

SPVM::Regex - Github

Author

Yuki Kimoto

Contributors

Copyright & License

Copyright (c) 2023 Yuki Kimoto

MIT License