JavaScript RegExp \ooo Metacharacter

What You’ll Learn

The \ooo form is a legacy octal escape: a backslash followed by one to three octal digits (0–7). It matches the character at that numeric value—for example, \101 is capital A and \012 is a newline. You will mostly see this in older code; modern patterns prefer \xHH or \uXXXX.

Introduction

Before hex (\xHH) and Unicode (\uXXXX) escapes became standard, many languages—including JavaScript—allowed octal numeric escapes. Each digit after the backslash must be 0–7, and you may write one, two, or three digits.

Octal escapes still work in JavaScript regular expressions today, but they are considered legacy. They remain important for reading old scripts and understanding how numeric character codes relate across octal, decimal, and hex notation.

Understanding the Octal \ooo Escape

An octal escape matches one character whose code unit equals the octal number. Octal 101 equals decimal 65, which is the letter A.

/\101/.test("A");        // true  (octal 101 = dec 65)
/\141/.test("a");        // true  (octal 141 = dec 97)
/\012/.test("a\nb");      // true  (octal 12 = dec 10 = LF)

"A" === "\101";          // true in strings too

The maximum value is 377 octal (255 decimal). Values above that cannot be expressed with a three-digit octal escape.

How to Use Octal Escapes in JavaScript

Octal escapes appear in legacy patterns and string literals:

/\101/.test("ABC");              // true (A at start)
"line1\012line2".split(/\012/);  // split on LF
/\011/.test("a\tb");             // true (octal 11 = tab)
parseInt("101", 8);              // 65 — convert octal to decimal

When writing new regex, reach for \xHH or \uXXXX instead. They are easier to read and avoid clashes with backreferences.

📝 Syntax

\o               // one octal digit (0-7)
\oo              // two octal digits
\ooo             // three octal digits (max \377)
\101             // letter A (octal 101 = dec 65)
\012             // line feed (same as \n)
\011             // horizontal tab (same as \t)
\0               // null when not followed by 0-7

Common patterns

• /\101/ — match capital A by octal code.
• /\141/ — match lowercase a (octal 141).
• /\012/g — find line feed characters.
• /\011/ — match tab (octal 11 = decimal 9).

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples cover letter matching, newlines, lowercase octal, cross-escape comparison, and one- vs two-digit forms.

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

console.log(parseInt("101", 8));   // 65

true
false
true
65

const text = "line1\nline2";

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

true
["line1", "line2"]
true

const word = "cat";

console.log(/\141/.test(word));  // true
console.log(word.match(/\141/)[0]); // "a"
console.log(parseInt("141", 8));   // 97

true
a
97

const ch = "A";

console.log(/\101/.test(ch));    // true (octal)
console.log(/\x41/.test(ch));    // true (hex)
console.log(/\u0041/.test(ch)); // true (unicode)

true
true
true

console.log(parseInt("65", 8));   // 53 (digit "5")
console.log(/\65/.test("5"));     // true

console.log(parseInt("101", 8));  // 65 (letter A)
console.log(/\101/.test("A"));    // true

console.log(/\011/.test("a\tb")); // true (tab)

53
true
65
true
true

🚀 Common Use Cases

• Reading legacy regex — decode old patterns that use octal codes.
• Maintenance — understand historic scripts before migrating to hex.
• Learning number bases — connect octal, decimal, and hex character codes.
• Control characters — recognize \012 (LF) and \011 (tab) in old dumps.
• Documentation — translate octal tables from Unix-era references.
• Migration — convert octal escapes to \xHH for modern codebases.

Important Considerations

• Legacy syntax — prefer \xHH or \uXXXX in new regex.
• Backreferences — \1–\9 refer to capture groups, not octal digits.
• Digits 0–7 only — 8 and 9 are not valid octal digits.
• Max \377 — three octal digits cap at 255 decimal; no emoji or BMP+ via octal alone.
• Not hex — octal \101 is not the same notation as hex \x101 (which would be invalid/consumed differently).

📝 Notes

• Octal escapes use digits 0–7 only (base 8).
• \0 alone matches null; see \0 for details.
• Previous metacharacter: \xHH hex byte escape.
• Next topic: d indices modifier.
• Convert octal to decimal in DevTools: parseInt("101", 8).
• For new code, prefer \xHH over octal for readability.

💡 Best Practices