Positive Lookahead (Password)
Use positive lookahead `(?=...)` to require the password contain at least one digit and one uppercase letter.
Try it in RegexPro →Available in
JavaScript / ECMAScript code
const re = new RegExp("^(?=.*\\d)(?=.*[A-Z])[A-Za-z\\d]{8,}$", "");
const input = "Password1";
const match = input.match(re);
console.log(match ? match[0] : null);Uses `String.prototype.match`, which returns the first match or null.
Python (re) code
import re
pattern = re.compile(r"^(?=.*\d)(?=.*[A-Z])[A-Za-z\d]{8,}$")
input_text = "Password1"
for m in pattern.finditer(input_text):
print(m.group(0))Stdlib `re` module — no third-party dependency. Works on Python 3.6+.
Why it doesn't work in GO
Go's RE2 engine doesn't support lookarounds (`(?=...)`, `(?<=...)`, etc.) — they break the linear-time matching guarantee.
Approach
Restructure to capture the surrounding context as a group instead, or use JS / Python where lookarounds are available.
Read the full guide →Workaround code in Go (RE2)
package main
import (
"fmt"
"regexp"
"unicode"
)
// RE2 doesn't support lookarounds. The fix: match a BROADER candidate
// without the lookaround, then verify the condition in Go code.
//
// Example: instead of `(?=.*\d)[A-Za-z\d]{8,}` (require a digit),
// match the candidate then check `HasDigit(s)` separately.
func HasDigit(s string) bool {
for _, r := range s {
if unicode.IsDigit(r) {
return true
}
}
return false
}
func main() {
re := regexp.MustCompile(`[A-Za-z\d]{8,}`) // simplified, no lookaround
input := "Password1 weakpass StrongerOne9"
for _, candidate := range re.FindAllString(input, -1) {
if HasDigit(candidate) { // the lookaround condition, in code
fmt.Println(candidate)
}
}
}Match a broader candidate without the lookaround, then verify the constraint in Go. Keeps the linear-time guarantee.
Pattern
^(?=.*\d)(?=.*[A-Z])[A-Za-z\d]{8,}$Raw source: ^(?=.*\d)(?=.*[A-Z])[A-Za-z\d]{8,}$
How it works
Examples
Input
Password1Matches
Password1
Input
weakpassNo match
—Input
ALLCAPSNODIGITNo match
—Common use cases
- •Password complexity enforcement
- •Form validation with multiple co-required tokens
- •Filename validation (must end with extension AND start with letter)
- •Compound-rule input filtering
Related patterns
Negative Lookahead
Text ProcessingUse negative lookahead `(?!...)` to match words that are NOT in a blocklist (here: log-level keywords).
Password (No Special Chars)
ValidationValidate passwords requiring at least one lowercase, one uppercase, one digit, and minimum 8 characters — no special characters required.
Negative Lookbehind (Decimals Without $)
Text ProcessingUse negative lookbehind `(?<!...)` to match decimal numbers NOT preceded by a dollar sign.
Non-Capturing Group (Image URL)
Text ProcessingUse non-capturing groups `(?:...)` to alternate without polluting the captured-groups list.