A regular expression can require two things in different ways. The choice of an AND operator in regex depends on whether those things must appear in a fixed sequence or merely occur somewhere in the same input.
Regex AND Operator: Choose the Meaning First
Concatenation joins patterns in order. The pattern /catdog/ matches catdog because cat is immediately followed by dog. It does not match dogcat or cat-dog. Use /cat.*dog/ to allow characters between them, while still requiring cat first. In JavaScript, . does not normally match line terminators; the s flag changes that behavior.
The word AND in regex discussions can also mean that several independent tests must pass. For example, an identifier might need at least one ASCII letter and at least one digit, in either order. Concatenation alone imposes an order, so it does not express that requirement cleanly. A regex AND operator for independent conditions can be modeled with lookaheads, provided the engine supports them.
Combine Checks With Lookahead
In JavaScript, this example validates a single-line identifier containing only ASCII letters and digits. It must contain at least one of each:
const identifier = /^(?=[A-Za-z0-9]*[A-Za-z])(?=[A-Za-z0-9]*[0-9])[A-Za-z0-9]+$/;
identifier.test("abc123"); // true
identifier.test("7alpha"); // true
identifier.test("letters"); // false: no digit
identifier.test("12345"); // false: no letter
identifier.test("ab-12"); // false: hyphen is not allowed
Each positive lookahead begins at the start of the input. The first searches for a letter after zero or more permitted characters; the second searches for a digit in the same way. A successful assertion leaves the matching position unchanged. The final character class then consumes one or more permitted characters, while the anchors constrain the match to the input boundaries. The flags m, g, and y are intentionally absent: multiline changes anchor behavior, while global and sticky expressions carry state between calls to test.
This is one way to combine regex conditions with AND: both assertions and the consuming part must succeed. They do not need to find their required characters in a particular order. The checks may overlap when a different set of requirements permits it; they are tests, not separate slices of the input.
Define the Scope and Alternatives
The example is case-sensitive and deliberately accepts only ASCII letters. If your identifiers allow Unicode letters, spaces, or punctuation, change both the permitted character class and the assertions to match the actual rules. Decide whether an empty string is valid as well: the final + currently rejects it.
Lookahead support varies by engine. JavaScript supports it, but RE2 does not support look-around assertions. Where lookahead is unavailable, test the same whole input with separate expressions and combine the Boolean results in application code. For instance, check that the input contains a letter, contains a digit, and consists only of allowed characters. Use the engine’s full-match API for the last check, or understand its anchor behavior before relying on anchors.
An AND operation in a regular expression can conceal which condition failed. Separate tests are often easier to maintain when each failure needs a distinct message. A combined pattern can be convenient when an interface accepts only one expression. In either case, keep the character rules aligned across all checks and test the empty string, invalid characters, and both possible orders.
If a value passes with only one required property, inspect whether the tests were joined with OR or whether one assertion was omitted. If a valid value fails only when the order is reversed, replace an ordered sequence with independent checks against the same input.