---
title: Regex compiled inside a loop
description: Datadog, the leading service for cloud-scale monitoring.
breadcrumbs: >-
  Docs > Datadog Security > Code Security > Static Code Analysis (SAST) > SAST
  Rules > Regex compiled inside a loop
---

# Regex compiled inside a loop

{% callout %}
# Important note for users on the following Datadog sites: app.ddog-gov.com, us2.ddog-gov.com

{% alert level="danger" %}
This product is not supported for your selected [Datadog site](https://docs.datadoghq.com/getting_started/site.md). ({% placeholder "user-datadog-site-name" /%}).
{% /alert %}

{% /callout %}

## Metadata{% #metadata %}

**ID:** `rust-code-quality/regex-creation-in-loops`

**Language:** Rust

**Severity:** Warning

**Category:** Performance

## Description{% #description %}

Constructing a `Regex` inside a loop causes it to be recompiled on every iteration. Regex compilation is expensive — move the regex outside the loop or use `std::sync::OnceLock` to compile it once.

## Example{% #example %}

```rust
// Before — recompiled on every iteration
for item in items {
    let re = Regex::new(r"\d+").unwrap();
    if re.is_match(item) { ... }
}

// After — compiled once before the loop
let re = Regex::new(r"\d+").unwrap();
for item in items {
    if re.is_match(item) { ... }
}
```

## Non-Compliant Code Examples{% #non-compliant-code-examples %}

```rust
use regex::Regex;

fn search_in_for_loop(items: &[&str]) -> Vec<bool> {
    let mut results = vec![];
    for item in items {
        let re = Regex::new(r"\d+").unwrap();
        results.push(re.is_match(item));
    }
    results
}

fn search_in_while_loop(items: &[&str]) -> bool {
    let mut i = 0;
    while i < items.len() {
        let re = Regex::new(r"\d+").unwrap();
        if re.is_match(items[i]) {
            return true;
        }
        i += 1;
    }
    false
}

fn search_in_loop_block(items: &[&str]) -> bool {
    let mut i = 0;
    loop {
        if i >= items.len() { break; }
        let re = Regex::new(r"\d+").unwrap();
        if re.is_match(items[i]) { return true; }
        i += 1;
    }
    false
}

fn search_in_while_let(mut iter: impl Iterator<Item = &'static str>) -> bool {
    while let Some(item) = iter.next() {
        let re = Regex::new(r"\d+").unwrap();
        if re.is_match(item) { return true; }
    }
    false
}
```

## Compliant Code Examples{% #compliant-code-examples %}

```rust
use regex::Regex;

fn search_outside_loop(items: &[&str]) -> Vec<bool> {
    let re = Regex::new(r"\d+").unwrap();
    let mut results = vec![];
    for item in items {
        results.push(re.is_match(item));
    }
    results
}

fn no_regex_in_loop(items: &[i32]) -> i32 {
    let mut sum = 0;
    for item in items {
        sum += item;
    }
    sum
}

fn dynamic_pattern(items: &[&str]) -> Vec<bool> {
    let mut results = vec![];
    for item in items {
        let re = Regex::new(&format!("test{item}")).unwrap();
        results.push(re.is_match(item));
    }
    results
}
```
  Seamless integrations. Try Datadog Code SecurityDatadog Code Security 
{% icon name="icon-external-link" /%}