Struct Regex

pub struct Regex { /* private fields */ }

Implementations

impl Regex

pub fn new(pat: &str) -> Result<Self, Error>

pub fn is_match(&self, text: &str) -> bool

Returns true if and only if there is a match for the regex in the string given.

Example

Test if some text contains at least one word with exactly 13 Unicode word characters:

let text = "I categorically deny having triskaidekaphobia.";
assert!(Regex::new(r"\b\w{13}\b").unwrap().is_match(text));

pub fn is_match_at(&self, text: &str, index: usize) -> bool

Returns the same as is_match, but starts the search at the given offset.

The significance of the starting point is that it takes the surrounding context into consideration. For example, the \A anchor can only match when start == 0.

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

Returns the start and end byte range of the leftmost-first match in text. If no match exists, then None is returned.

Note that this should only be used if you want to discover the position of the match. Testing the existence of a match is faster if you use is_match.

Example

Find the start and end location of the first word with exactly 13 Unicode word characters:

let text = "I categorically deny having triskaidekaphobia.";
let mat = Regex::new(r"\b\w{13}\b").unwrap().find(text).unwrap();
assert_eq!(mat.start(), 2);
assert_eq!(mat.end(), 15);

pub fn find_at<'t>(&self, text: &'t str, start: usize) -> Option<Match<'t>>

Returns the same as find, but starts the search at the given offset.

The significance of the starting point is that it takes the surrounding context into consideration. For example, the \A anchor can only match when start == 0.

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

Returns an iterator for each successive non-overlapping match in text, returning the start and end byte indices with respect to text.

Example

Find the start and end location of every word with exactly 13 Unicode word characters:

let text = "Retroactively relinquishing remunerations is reprehensible.";
let re = Regex::new(r"\b\w{13}\b").unwrap();
let mut iter = re.find_iter(text);
assert_eq!(iter.next().unwrap().as_str(), "Retroactively");
assert_eq!(iter.next().unwrap().as_str(), "relinquishing");
assert_eq!(iter.next().unwrap().as_str(), "remunerations");
assert_eq!(iter.next().unwrap().as_str(), "reprehensible");
assert!(iter.next().is_none());

Trait Implementations

impl Clone for Regex

fn clone(&self) -> Regex

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Regex

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

Formats the value using the given formatter.

impl Hash for Regex

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Regex

fn eq(&self, other: &Regex) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Regex

impl StructuralPartialEq for Regex