Course contentsShow
← JavaScript
Lesson 1716 of 2,72336. Regular ExpressionsFree lesson

Password Validation with Lookaheads

Combining multiple lookaheads to enforce complex requirements like uppercase, digits, and length.

Password Validation with Lookaheads

What you'll learn: How to combine multiple lookaheads to enforce complex password requirements like uppercase letters, digits, and minimum length—all in a single regex pattern.

The Power of Multiple Lookaheads

When validating passwords, you typically need to check several independent conditions: "Must contain at least one uppercase letter," "Must have at least one digit," "Must be 8+ characters long," etc.

Lookaheads shine here because each lookahead checks one requirement independently, and you can chain them together at the start of your pattern. Since lookaheads are zero-width (they don't consume characters), they all examine the same input from position zero.

Building a Password Validator

Here's the pattern:

const passwordRegex = /^(?=.*[A-Z])(?=.*\d)(?=.{8,})/;

console.log(passwordRegex.test("Password123")); // true
console.log(passwordRegex.test("password123")); // false (no uppercase)
console.log(passwordRegex.test("PASSWORD"));    // false (no digit)
console.log(passwordRegex.test("Pass1"));       // false (too short)

Breaking it down:

  • ^ — Start at the beginning
  • (?=.*[A-Z]) — Look ahead to ensure there's an uppercase letter somewhere
  • (?=.*\d) — Look ahead to ensure there's a digit somewhere
  • (?=.{8,}) — Look ahead to ensure there are at least 8 characters total

Each lookahead scans the entire string independently. If all succeed, the pattern matches.

Adding More Requirements

Need a special character too?

const strongPassword = /^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)(?=.*[@$!%*?&])(?=.{8,})/;

This validates uppercase, lowercase, digit, special character, and minimum length—all simultaneously.

Key Takeaway: Combining multiple positive lookaheads at the start of a regex lets you enforce several independent password requirements in one clean pattern, with each lookahead checking a specific condition without consuming characters.