Mastering Regex: How to Build Precise and Efficient Regular Expressions

Overview

Understanding that mastering a language involves both reading and writing, the chapter focuses on constructing appropriate regular expressions for given problems.

1. Balance Principle

When building a regex you must balance matching expected strings, not matching unexpected ones, readability/maintainability, and efficiency.

2. Prerequisites for Building Regex

2.1 Determine if regex is suitable; not all string problems need regex.

2.2 Assess necessity; avoid overusing regex when simple string APIs suffice.

Examples using JavaScript split, indexOf, substring, and substr illustrate alternatives.

2.3 Decide whether a complex regex is needed; for password validation a combination of simpler regexes can replace a single complex pattern.

var regex1 = /^[0-9A-Za-z]{6,12}$/;
var regex2 = /^[0-9]{6,12}$/;
var regex3 = /^[A-Z]{6,12}$/;
var regex4 = /^[a-z]{6,12}$/;
function checkPassword(str) {
    if (!regex1.test(str)) return false;
    if (regex2.test(str)) return false;
    if (regex3.test(str)) return false;
    if (regex4.test(str)) return false;
    return true;
}

3. Accuracy

Accuracy means matching intended targets while rejecting others. Examples include matching fixed‑line telephone numbers and floating‑point numbers.

Fixed‑line phone regexes: /^0\d{2,3}[1-9]\d{6,7}$/ Combined version with shared prefix:

/^(0\d{2,3}-?|\(0\d{2,3}\))[1-9]\d{6,7}$/

Floating‑point numbers require handling optional sign, integer, and decimal parts. A concise pattern is:

/^[+-]?(\d+\.\d+|\d+|\.\d+)$/

4. Efficiency

After ensuring accuracy, consider performance. The regex engine works in stages: compile, set start position, attempt match, backtrack, and finish. Inefficiencies arise mainly during matching and backtracking.

Optimization techniques:

Use specific character classes instead of wildcards to avoid unnecessary backtracking, e.g., /"[^"]*"/ instead of /".*"/.

Employ non‑capturing groups (?:...) when the captured value is not needed.

Factor out deterministic characters to reduce backtracking, e.g., replace /a+/ with /aa*/.

Extract common parts from alternatives, e.g., /^(?:abc|def)/ instead of /^abc|^def/.

Minimize the number and range of branches, e.g., /rea?d/ instead of /red|read/.

Conclusion

The chapter emphasizes a pragmatic approach: write a regex that satisfies the requirement, balance accuracy and efficiency, and avoid over‑optimizing unless necessary.