![](https://ipfs.pics/ipfs/QmRewcCALeid2GMkjouKTcYcTwVoJ4XcfrxnUjMQ55q25L)

Hi again everyone, here comes another [Rust lang series](https://steemit.com/created/rust-series) episode, this time about Rust and regular expressions.  Regular expressions (regex) are standard for a powerful operations with strings.

Although String struct provides methods like **find** and **replace** to search and replace text, whenever we need to create more generic pattern, we need Regular expressions. If you are not familiar with regular expressions, I advice you to get some basics first for example [here](http://www.regular-expressions.info/).

## Dependencies
To utilize regular expressions in Rust we mut  regex crate into our dependencies in Cargo.toml because this is not part of standard library.

```toml
[dependencies]
regex = "0.1.77"
```

## Matching strings

```rust
extern crate regex;

use regex::Error;

fn main() {
    use regex::Regex;
    let date_pattern = r"^\d{4}-\d{2}-\d{2}$";
    let res = Regex::new(date_pattern);

    if let Ok(regex) = res {
        println!("regex ok, trying to match...");
        let str = "2016-01-01";
        let matches = regex.is_match(str);
        if matches {
            println!("{} matches pattern {}", str, date_pattern);
        } else {
            println!("{} doesn't match pattern {}", str, date_pattern);
        }

    } else {
        println!("{:?}", res);
    }
}
```

### Output
```
regex ok, trying to match...
2016-01-01 matches pattern ^\d{4}-\d{2}-\d{2}$
```

## Breaking down

**regex** is crate providing regex::Regex API.

**Regex::new()** compiles regular expression that can be used for futher processing.

**is_match()** method returns true if matches given string, false otherwise

## Finding pattern
Regex provides multiple method. One of most usefull is **find** method for finding pattern. Let's find "Steemit is great"

```rust
extern crate regex;

fn main() {
    use regex::Regex;
    let steem_pattern = r"Steemit is\s\w\sgreat";
    let res = Regex::new(steem_pattern);

    if let Ok(regex) = res {
        println!("regex ok, trying to find text");
        let str = "After all Steemit is a great platform";
        let found = regex.find(str);
        if let Some(res) = found {
            println!("'{}' pattern found in '{}' at {:?}", steem_pattern, str, res);
        } else {
            println!("'{}' pattern not found in '{}'", steem_pattern, str);
        }

    } else {
        println!("{:?}", res);
    }
}
```

### Output
```
regex ok, trying to find text
'Steemit is\s\w\sgreat' pattern found in 'After all Steemit is a great platform' at (10, 28)
```

### Breaking down
Everything is quite like the same as in previous example except this time we call find() method which returns **Option**. If found **Some** with tuple containing integer with start and end matching position.

## Other useful Regex methods
There are some other useful methods in Regex besided these two mostly used. The most useful are:

* split - can split string based on regular expression
* replace - provides string replacement based on regular expression
* capture  - provides string search with sub-matches

## Postfix

That's all for now, thank you for your appreciations, feel free to comment and point out possible mistakes (first 24 hours works the best but any time is fine). May Jesus bless your programming skills, use them wisely and see you next time.

Meanwhile you can also check the official documentation for additional related information:

* https://doc.rust-lang.org/regex/regex/index.html
* https://doc.rust-lang.org/regex/regex/struct.Regex.html
* https://doc.rust-lang.org/regex/regex/struct.Captures.html