Struct CachedJsRegex 

pub struct CachedJsRegex { /* private fields */ }

Implementations

impl CachedJsRegex

pub fn new(source: String) -> Result<Self>

Get or create a cached regex. This will return the previous instance if it’s already cached.

pub fn source(&self) -> &str

Methods from Deref<Target = Regex>

pub fn find(&self, text: &str) -> Option<Match>

Searches text to find the first match.

pub fn find_iter<'r, 't>( &'r self, text: &'t str, ) -> Matches<BacktrackExecutor<'r, Utf8Input<'t>>>

Searches text, returning an iterator over non-overlapping matches. Note that the resulting Iterator borrows both the regex 'r and the input string as 't.

pub fn find_from<'r, 't>( &'r self, text: &'t str, start: usize, ) -> Matches<BacktrackExecutor<'r, Utf8Input<'t>>>

Returns an iterator for matches found in ‘text’ starting at byte index start. Note this may be different from passing a sliced text in the case of lookbehind assertions. Example:

 use regress::Regex;
 let text = "xyxy";
 let re = Regex::new(r"(?<=x)y").unwrap();
 let t1 = re.find(&text[1..]).unwrap().range();
 assert!(t1 == (2..3));
 let t2 = re.find_from(text, 1).next().unwrap().range();
 assert!(t2 == (1..2));

pub fn find_ascii(&self, text: &str) -> Option<Match>

Searches text to find the first match. The input text is expected to be ascii-only: only ASCII case-folding is supported.

pub fn find_iter_ascii<'r, 't>( &'r self, text: &'t str, ) -> Matches<<BacktrackExecutor<'r, Utf8Input<'t>> as Executor<'r, 't>>::AsAscii>

Searches text, returning an iterator over non-overlapping matches. The input text is expected to be ascii-only: only ASCII case-folding is supported.

pub fn find_from_ascii<'r, 't>( &'r self, text: &'t str, start: usize, ) -> Matches<<BacktrackExecutor<'r, Utf8Input<'t>> as Executor<'r, 't>>::AsAscii>

Returns an iterator for matches found in ‘text’ starting at byte index start.

pub fn replace(&self, text: &str, replacement: &str) -> String

Replaces the first match of the regex in text with the replacement string.

The replacement string may contain capture group references in the form $1, $2, etc., where $1 refers to the first capture group, $2 to the second, and so on. $0 refers to the entire match. Use $$ to insert a literal $.

If no match is found, the original text is returned unchanged.

Examples

use regress::Regex;

let re = Regex::new(r"(\w+)\s+(\w+)").unwrap();
let result = re.replace("hello world", "$2 $1");
assert_eq!(result, "world hello");

let re = Regex::new(r"(\d{4})-(\d{2})-(\d{2})").unwrap();
let result = re.replace("2023-12-25", "$2/$3/$1");
assert_eq!(result, "12/25/2023");

pub fn replace_all(&self, text: &str, replacement: &str) -> String

Replaces all matches of the regex in text with the replacement string.

The replacement string may contain capture group references in the form $1, $2, etc., where $1 refers to the first capture group, $2 to the second, and so on. $0 refers to the entire match. Use $$ to insert a literal $.

Examples

use regress::Regex;

let re = Regex::new(r"(\w+)\s+(\w+)").unwrap();
let result = re.replace_all("hello world foo bar", "$2-$1");
assert_eq!(result, "world-hello bar-foo");

let re = Regex::new(r"\b(\w)(\w+)").unwrap();
let result = re.replace_all("hello world", "$1.$2");
assert_eq!(result, "h.ello w.orld");

pub fn replace_with<F>(&self, text: &str, replacement: F) -> String

where F: FnOnce(&Match) -> String,

Replaces the first match of the regex in text using a closure.

The closure receives a &Match and should return the replacement string. This is useful for dynamic replacements that depend on the match details.

If no match is found, the original text is returned unchanged.

Examples

use regress::Regex;

let re = Regex::new(r"\d+").unwrap();
let text = "Price: $123";
let result = re.replace_with(text, |m| {
    let num: i32 = m.as_str(text).parse().unwrap();
    format!("{}", num * 2)
});
assert_eq!(result, "Price: $246");

pub fn replace_all_with<F>(&self, text: &str, replacement: F) -> String

where F: Fn(&Match) -> String,

Replaces all matches of the regex in text using a closure.

The closure receives a &Match and should return the replacement string. This is useful for dynamic replacements that depend on the match details.

Examples

use regress::Regex;

let re = Regex::new(r"\d+").unwrap();
let text = "Items: 5, 10, 15";
let result = re.replace_all_with(text, |m| {
    let num: i32 = m.as_str(text).parse().unwrap();
    format!("[{}]", num * 10)
});
assert_eq!(result, "Items: [50], [100], [150]");

Trait Implementations

impl Clone for CachedJsRegex

fn clone(&self) -> CachedJsRegex

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CachedJsRegex

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for CachedJsRegex

type Target = Regex

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de> Deserialize<'de> for CachedJsRegex

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CachedJsRegex

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.