Character classes & sets

What a character class is

A regular expression, or regex, reads text one character at a time. Each part of the pattern stands for one spot in the text. A character class says which characters are allowed in one spot. For example:

• \d allows one digit.
• [abc] allows one a, one b, or one c.
• [^abc] allows one character that is not a, b, or c.
• \p{L} allows one letter from any language.

The previous lesson, Patterns & flags, showed how to write a regex, add flags, and use test, match, and replace. This lesson answers one question: which characters does one spot allow? To review text in JavaScript, see strings and Unicode & strings.

The table compares four tools that are easy to mix up. Read each row from left to right.

JavaScript has short codes for common sets. Each one matches one character. The first two know only the basic English characters. This basic set is called ASCII.

• \d matches one digit from 0 to 9. It does not match digits from other writing systems, such as the Arabic digit three, ٣.
• \w matches one word character: a letter from A to Z or a to z, a digit, or the underscore _. It does not match letters with accents, such as é.
• \s matches one space-like character: a space, a tab, a line break, or a rarer space such as the non-breaking space (a space that keeps two words on the same line).
• The dot . matches almost any one character. It skips line breaks.

A capital letter flips the meaning. \D matches one character that is not a digit. \W and \S work the same way.

The step-through below runs real checks. Pick a group of classes, then look for these results:

• \d skips ٣, but \p{N} (any number) matches it.
• \w matches the underscore _, but not é.
• The dot skips a line break, unless you add the s flag.
• An emoji such as 😄 is stored as two pieces in a string. Without the u or v flag, the dot matches each piece, so you get two matches. With u, you get one.

1const samples = [Run2  ["ASCII 9", "9"],3  ["Arabic ٣", "٣"],4  ["A", "A"],5  ["underscore", "_"],6  ["space", " "],7];8 9const labels = (regex) => samples10  .filter(([, value]) => regex.test(value))11  .map(([label]) => label)12  .join(", ");13 14console.log(labels(/\d/u));15console.log(labels(/\D/u));16console.log(/\p{N}/u.test("٣"));

Next, try each class on one sample string. Pick a class and see which characters it matches.

1const sample = "A é β 9 ٣ _ -\u00A0.\n☕ 😀";2const matches = sample.match(/\d/gu) ?? [];3console.log(matches.join(" | "));

Square brackets make your own set. The set still matches only one character.

• [abc] matches one a, one b, or one c.
• A hyphen between two characters makes a range. [A-Z] means any one capital letter from A to Z. [A-Z0-9] means one capital letter or one digit.
• A caret ^ right after [ flips the set. [^A-Z0-9] means one character that is not a capital letter or a digit.

1console.log("cab".match(/[abc]/g).join(""));2console.log("B7!".match(/[A-Z0-9]/g).join(""));3console.log("B7!".match(/[^A-Z0-9]/g).join(""));4console.log("a-z".match(/[a\-z]/g).join(""));5console.log("a-z]^".match(/[a-z\]\^-]/g).join("|"));6console.log("a1!".match(/[^a-z0-9]/g).join(""));

In plain words, line by line:

1. Line 1: [abc] matches c, a, and b, so it prints cab.
2. Line 2: [A-Z0-9] matches the capital B and the digit 7. It prints B7.
3. Line 3: the caret flips the set. Only ! is not a capital letter or a digit, so it prints !.
4. Line 4: \- is a hyphen with a backslash before it, so it means a real -, not a range. The set is a, -, or z, and it prints a-z.
5. Line 5: the set holds the range a-z, a real ] written \], a real ^ written \^, and a real - at the end. Every character matches, so it prints a|-|z|]|^.
6. Line 6: [^a-z0-9] keeps only what is not a small letter or a digit. It prints !.

To escape a character means to put a backslash \ before it, so it stands for itself. The rules are different inside and outside the brackets:

• Outside brackets, many characters have a special meaning: ., +, ?, *, (, ), {, }, |, ^, $, and \.
• Inside brackets, only a few need care: ] (it closes the set), \, ^ at the very start, and - between two characters.
• For a real hyphen, put - first or last in the set, or write \-.

Unicode is the big list of characters from every writing system. It gives each character labels, called properties, such as "letter", "number", or "Greek". A regex can match by property:

• \p{...} (small p) matches one character that has the property.
• \P{...} (capital P) matches one character that does not have it.
• Both need the u or v flag.

Some useful properties:

• \p{L}: any letter.
• \p{Lu}: any capital letter.
• \p{N}: any number.
• \p{Script=Greek}: any character from the Greek alphabet.
• \p{Emoji_Presentation}: characters that show as an emoji picture by default.

1const text = "A é Β ٣ 5";Run2 3console.log(text.match(/\p{L}/gu).join(" "));4console.log(text.match(/\p{N}/gu).join(" "));5console.log(text.match(/\P{L}/gu).filter((ch) => ch !== " ").join("|"));6console.log(/^\p{L}$/u.test("e\u0301"), /^\p{M}$/u.test("\u0301"));

A property only describes characters. It does not choose your rules for you. For example:

• For names from many countries, you may need letters, accent marks, spaces, apostrophes, and hyphens.
• For usernames, you may want only basic English letters and digits, on purpose.

Write the regex for the rule you chose. The last line of the lab shows why. e\u0301 is the letter e followed by a separate accent mark. On screen it looks like é, but it is two characters. So it is not one \p{L} letter. The accent alone matches \p{M} (any mark).

The v flag is a newer, stronger version of the u flag. It adds four things:

• -- takes one set away from another. This is called set difference.
• && keeps only characters that are in both sets. This is called intersection.
• A set can hold other sets in brackets, such as [[a-z]--[aeiou]].
• Some properties match a whole emoji made of several characters as one match. These are called string properties.

To check whether a regex uses v, read its unicodeSets property. It is true or false, and you can only read it, not change it.

1const text = "alphabet β123";2const consonantsAndGreek = text.match(/[\p{L}--[aeiou]]/gv) ?? [];3console.log(consonantsAndGreek.join(""));

In the string property choice, the last line prints true, because new RegExp("", "v").unicodeSets is true for a regex made with v. Older browsers do not know the v flag. To check, make a tiny v regex inside a try block. If it throws an error, use a simpler u pattern instead.

The v flag gives new meaning to some symbols inside brackets, so it is stricter about escaping. For example, a real | inside a v set must be written \|. The next code throws an error on purpose. Read the error, then fix it to [a\|b].

1// In v mode, | is reserved inside a character class.2new RegExp("[a|b]", "v");

When a learner types a search term, that text is data. If you pass it straight to new RegExp(term), symbols such as +, [, and ? turn into regex rules. For example, a+b would mean "one or more a, then b". The fix is to escape the term first, then build the regex.

1function escapeForRegExp(input) {2  return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");3}4 5const userText = "a+b [test]";6const escaped = escapeForRegExp(userText);7const regex = new RegExp(escaped, "g");8 9console.log(escaped);10console.log("find a+b [test] here".replace(regex, "<mark>$&</mark>"));

In plain words, line by line:

1. Lines 1 to 3 make the helper escapeForRegExp. Line 2 finds every special character and puts a backslash before it. In the replacement, $& means "the character that was found".
2. Line 6 escapes the user text. Line 7 builds the regex from the escaped text.
3. Line 9 prints the escaped text, a\+b \[test\].
4. Line 10 finds the real text a+b [test] and wraps it in <mark> tags.

RegExp.escape is a newer built-in method from ES2025, the 2025 version of JavaScript. It does the same job and handles more unusual cases. MDN's browser support data lists it in Chrome 136+, Firefox 134+, Safari 18.2+, and Node.js 24+. This site's tests run on Node 22, which does not have it. So Node 22 code still needs the helper above, or a polyfill (code that adds a missing feature).

1const userText = "a+b [test]";2const escaped = RegExp.escape(userText);3const regex = new RegExp(escaped, "g");4 5console.log(escaped);6console.log(regex.test("find a+b [test] here"));

Line 5 prints \x61\+b\x20\[test\]. RegExp.escape also escapes the first letter and the space, as \x61 and \x20. That looks odd, but it keeps the text safe wherever you put it in a regex. Line 6 prints true.

Where character classes are used

Character classes show up when you check input, clean up text, search, and split text into pieces. First write the rule in plain words, such as "basic English username" or "digits from a phone field". Then pick the class that says exactly that.

Each row starts with a real task. Read across to see a pattern and why it fits.

• Usernames: ^[A-Za-z0-9_-]+$ fits when you want only basic English letters, digits, _, and -.
• Phone digits: value.replace(/\D/g, "") removes everything that is not a digit from 0 to 9.
• Removing punctuation: text.replace(/[^\p{L}\p{N}\s]/gu, "") keeps letters, numbers, and spaces.
• Names from many countries: combine \p{L}, accent marks, spaces, and punctuation, but only the ones your app accepts.
• Search highlighting: escape the user's term, then build the regex.

Common misconceptions

• "\d means any digit." It means only 0 to 9. Use \p{N} for numbers from every writing system.
• "\w means any letter." It means basic English letters, digits, and _. It is not a good check for names from many countries.
• "The dot matches everything." It skips line breaks unless you add the s flag. Without u or v, it matches only half of an emoji such as 😄.
• "A bracket set matches a word." A set matches one character. The next lesson, on quantifiers, shows how to repeat it.
• "The v flag is just u with a new name." It adds --, &&, sets inside sets, string properties, and stricter escaping.
• "Text from a text box is safe to put in a regex." Text can contain regex symbols. Escape it before you build a pattern.

The table compares three tools. Read each row to see when to use the tool and when not to.

Key takeaways

• \d and \w know only basic English characters. \s also matches rarer spaces.
• The dot skips line breaks unless you add s. It needs u or v to match an emoji such as 😄 as one character.
• A bracket set matches one character. Ranges and ^ decide which characters are allowed.
• Unicode properties such as \p{L}, \p{Lu}, \p{N}, and \p{Script=Greek} need u or v.
• The v flag adds --, &&, sets inside sets, string properties, and stricter escaping.
• Escape user text with a helper or RegExp.escape before you build a regex from it.

Up next: Quantifiers. They let the class you chose repeat, with +, *, ?, and {n,m}.