JavaScript RegExp [abc] Character Class

What You’ll Learn

The [abc] character class matches exactly one character from a list you choose—in this case a, b, or c. It is the building block for custom letter sets, category codes, and flexible pattern matching beyond simple ranges like [0-9].

Introduction

Character classes let you match one character from a defined set. While [0-9] covers all digits with a range, [abc] lists specific characters explicitly. The engine picks whichever single letter appears at the current position.

Use this pattern when only a handful of letters are valid—quiz answers, hex digits without full ranges, product codes, or filtering text that must use a limited alphabet.

What Is the [abc] Character Class?

Square brackets create a character class. Each character listed inside is an alternative: the pattern matches if the next input character equals any one of them.

/[abc]/.test("dog");  // false (no a, b, or c)
/[abc]/.test("cab");  // true  (matches "c")
/[abc]/.test("A");    // false (uppercase A is different)

[abc], [bac], and [cab] are equivalent—order inside brackets does not change meaning. This is different from parentheses (abc), which match the literal three-letter sequence in order.

How to Use [abc] in JavaScript

Combine the class with RegExp methods the same way you would [0-9] or any other pattern:

const hasLetter = /[abc]/.test("hello");       // true  (contains "a")
const firstHit  = "xyz".match(/[abc]/);          // null
const allHits   = "alphabet".match(/[abc]/g);    // ["a", "b", "a"]
const cleaned   = "a1b!c".replace(/[^abc]/g, ""); // "abc"

Use test() for presence checks, match() to collect hits, and replace() to keep or remove characters based on membership in your set.

📝 Syntax

/[abc]/               // one of a, b, c
/[abc]+/              // one or more from the set
/^[abc]$/             // exactly one letter: a, b, or c
new RegExp("[abc]")   // constructor form

Common quantifiers with [abc]

• [abc]? — zero or one character from the set.
• [abc]+ — one or more characters, each from a, b, or c.
• [abc]{3} — exactly three characters from the set (e.g. "bac").
• ^[abc]+$ — entire string uses only a, b, and c.

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples cover testing, matching, validation, and filtering with a custom letter set.

const letterSet = /[abc]/;

console.log(letterSet.test("dog"));     // false
console.log(letterSet.test("cab"));     // true
console.log(letterSet.test("hello"));   // true  (contains "a" and "b")

false
true
true

const word = "alphabet";

const first = word.match(/[abc]/);
console.log(first[0]);           // "a"

const all = word.match(/[abc]/g);
console.log(all);                // ["a", "b", "a"]

a
["a", "b", "a"]

const codePattern = /^[abc]$/;

function isValidCode(code) {
  return codePattern.test(code);
}

console.log(isValidCode("b"));   // true
console.log(isValidCode("d"));   // false
console.log(isValidCode("ab"));  // false (two characters)

true
false
false

const wordPattern = /^[abc]+$/;

console.log(wordPattern.test("bac"));   // true
console.log(wordPattern.test("ccab"));  // true
console.log(wordPattern.test("back"));  // false ("k" not allowed)
console.log(wordPattern.test("ABC"));   // false (uppercase)

true
true
false
false

const messy = "a1b!c2x";

const allowed = messy.replace(/[^abc]/g, "");
console.log(allowed); // "abc"

const highlighted = messy.replace(/[abc]/g, "[$&]");
console.log(highlighted); // "[a]1[b]![c]2x"

abc
[a]1[b]![c]2x

🚀 Common Use Cases

• Multiple-choice validation — accept only a, b, or c answers.
• Custom alphabets — restrict input to a small allowed character set.
• Text filtering — extract or highlight specific letters from mixed content.
• Game logic — validate moves or tokens drawn from a limited letter pool.
• Parsing codes — match status flags represented by single letters.
• Building larger classes — combine sets: [abc0-9] for letters plus digits.

Important Considerations

• One character per token — bare [abc] matches a single position; use + for sequences.
• Case sensitivity — [abc] excludes uppercase unless you add ABC or the i flag.
• Not a literal word — [abc] matches "cab" one letter at a time; it is not the same as matching the word "abc" in order unless quantifiers align.
• Special characters — inside [ ], most characters are literal; place - at the start/end to match a hyphen literally.
• Metacharacters — ], \, and ^ (at the start) need careful placement or escaping inside classes.

📝 Notes

• Combine with digits: [abc0-9] matches one letter a–c or one digit.
• Negate the set: [^abc] matches any character except a, b, and c.
• For all lowercase letters, prefer [a-z] over listing 26 characters.
• Use explicit sets when the allowed pool is small and non-contiguous.
• See [0-9] for digit ranges and [^0-9] for negated classes.
• Inside classes, . is usually a literal dot, not “any character.”

💡 Best Practices