JavaScript RegExp \xHH Metacharacter

What You’ll Learn

The \xHH escape matches a character by its two-digit hexadecimal byte value (0x00–0xFF). It is a compact way to target ASCII letters, digits, and control characters—such as newline (\x0A) and tab (\x09)—without typing them literally.

Introduction

JavaScript lets you refer to characters by numeric code using escape sequences. The \xHH form uses exactly two hexadecimal digits after \x, representing a byte value from 0 to 255. That covers all of ASCII and the upper half of the Latin-1 block.

Hex escapes appear in both string literals and regex patterns. They are especially handy for control characters you cannot easily type (like line feed or null) and for keeping patterns readable when working with byte-oriented protocols or legacy data formats.

Understanding the \xHH Metacharacter

\xHH matches one character whose code unit equals the hex value. For example, \x41 is capital A (decimal 65), and \x0A is line feed (same as \n).

/\x41/.test("A");        // true
/\x41/.test("B");        // false
/\x0A/.test("a\nb");      // true (LF in string)

"A" === "\x41";          // true

Always use two digits. Write \x0A, not \xA, for newline. Single-digit hex after \x is invalid JavaScript syntax.

How to Use \xHH in JavaScript

Use hex escapes in detection, splitting, character classes, and normalization:

/\x09/.test("a\tb");              // true (tab)
"one\x0Atwo".split(/\x0A/);      // ["one", "two"]
"abc".match(/[\x61-\x7A]/g);     // lowercase a,b,c
/\x20/.test("hello world");      // true (space = 0x20)

Build ranges inside character classes with hex bounds, such as [\x30-\x39] for ASCII digits 0–9.

📝 Syntax

\xHH            // one byte (2 hex digits)
\x41            // letter A (0x41)
\x0A            // line feed (same as \n)
\x09            // horizontal tab (same as \t)
[\x30-\x39]     // ASCII digits 0-9
[\x41-\x5A]     // ASCII uppercase A-Z

Common patterns

• /\x41/ — match the letter A by hex value.
• /\x0A/g — find line feed characters.
• /[\x30-\x39]+/ — one or more ASCII digits.
• /\x00/ — match a null byte (see also \0).

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples cover basic matching, control characters, tab bytes, digit ranges, and comparison with Unicode escapes.

console.log(/\x41/.test("A"));     // true
console.log(/\x41/.test("B"));     // false
console.log(/\x41/.test("ABC"));   // true

true
false
true

const text = "line1\nline2";

console.log(/\x0A/.test(text));       // true
console.log(text.split(/\x0A/));     // ["line1", "line2"]
console.log(/\n/.test(text));          // true (equivalent)

true
["line1", "line2"]
true

const row = "name\tage";

console.log(/\x09/.test(row));    // true
console.log(row.split(/\x09/));  // ["name", "age"]
console.log(/\t/.test(row));      // true (equivalent)

true
["name", "age"]
true

const re = /[\x30-\x39]+/g;
const text = "Room 25B has code 99";

console.log(text.match(re));  // ["25", "99"]
// \x30 = "0", \x39 = "9" — same as [0-9]

["25", "99"]

const ch = "A";

console.log(/\x41/.test(ch));    // true
console.log(/\u0041/.test(ch)); // true
console.log(/^A$/.test(ch));     // true

true
true
true

🚀 Common Use Cases

• Control characters — match LF, CR, tab, or null bytes by hex value.
• Binary protocols — parse fixed byte values in network or file formats.
• ASCII-safe patterns — write regex without non-ASCII literals in source.
• Legacy data — handle Latin-1 bytes in old log files or dumps.
• Hex documentation — mirror spec sheets that list codes as 0xNN.
• Digit/letter ranges — express ASCII bounds explicitly in classes.

Important Considerations

• Exactly two digits — pad with zero: \x0A, not \xA.
• 255 max — \xHH cannot express code points above 0xFF; use \uXXXX instead.
• Not a modifier — \x is an escape inside the pattern; the d flag is a separate modifier.
• Prefer shorthands — for common controls, \n and \t are often clearer than hex.
• UTF-8 awareness — multi-byte UTF-8 characters are not one \xHH unit; match Unicode explicitly when needed.

📝 Notes

• \xHH requires exactly two hexadecimal digits (0–9, A–F).
• The same escape works in strings: "\x41" produces "A".
• For code points above 0xFF, use \uXXXX.
• Previous metacharacter: \w word character.
• Next metacharacter: \ooo octal escape.
• Common controls: \x0A = \n, \x09 = \t, \x0D = \r.

💡 Best Practices