JS正则表达式：如何实现给定正则的否定版本并正确使用负向前瞻

Let's work through this together—your original regex wasn't correctly validating entire valid strings, which is why adding negative lookahead was causing headaches. Let's start by fixing the valid string pattern, then build the regex you need to catch invalid ones.

First, let's address the issue with your original regex: ^\b[A-Z]+|_+?[A-Z]+ doesn't check that the entire string only contains uppercase letters or underscores—it just matches fragments (like leading uppercase letters or underscore+uppercase chunks). The correct regex to match your valid strings (e.g., VALID_KEY, ANOTHER_VALID_KEY) is:

/^[A-Z_]+$/

This works because:

• ^ anchors to the start of the string
• [A-Z_]+ matches one or more characters that are either uppercase A-Z or underscore
• $ anchors to the end of the string (ensuring no extra characters slip through)

Now, to match invalid strings (empty string, ones with lowercase letters, dashes, etc.), here are two reliable approaches for JavaScript:

Approach 1: Negative Lookahead (your original goal) #

We can use a negative lookahead to assert that the string is NOT a valid one, then match any characters (including the empty string):

/^(?!^[A-Z_]+$).*$/

Breakdown:

• (?!^[A-Z_]+$): This negative lookahead checks that the entire string does NOT match the valid pattern. For empty strings, this is true because ^[A-Z_]+$ requires at least one character.
• .*: Matches any character (or none, for empty strings)
• Wrapping in ^ and $ ensures we validate the whole string, not just parts

Approach 2: Explicitly Match Invalid Scenarios #

Alternatively, we can directly target the invalid cases:

1. Empty string: ^$
2. Any string containing at least one character that's NOT uppercase A-Z or underscore: ^.*[^A-Z_].*$

Combine these with a logical OR (|):

/^$|^.*[^A-Z_].*$/

Verify Against Your Examples #

Both regexes will correctly:

• Match invalid strings:
  • Invalid_TEXT (contains lowercase letters)
  • all_in_small_invalid (all lowercase)
  • INVALID-DASH (contains a dash)
  • Empty string
• Not match valid strings:
  • VALID_KEY
  • ANOTHER_VALID_KEY

Why Your Original Attempts Failed #

Your original regex was focused on matching partial pieces of valid strings, not validating the entire string. When you tried adding negative lookahead, the partial matching logic conflicted with the full-string check—either causing syntax errors (from incorrect lookahead placement) or matching everything because the lookahead wasn't anchored to the start/end of the string.

JavaScript Usage Example #

Here's how to implement this in code to check for invalid strings:

// Pick either regex approach
const invalidRegex = /^(?!^[A-Z_]+$).*$/;
// const invalidRegex = /^$|^.*[^A-Z_].*$/;

function isStringInvalid(input) {
  return invalidRegex.test(input);
}

// Test cases
console.log(isStringInvalid("Invalid_TEXT")); // true
console.log(isStringInvalid("VALID_KEY")); // false
console.log(isStringInvalid("")); // true
console.log(isStringInvalid("INVALID-DASH")); // true

内容的提问来源于stack exchange，提问作者Marco