JavaScript RegExp \0 Metacharacter

What You’ll Learn

The \0 metacharacter matches the null character (NUL, Unicode U+0000). It is invisible, has ASCII code point 0, and appears in legacy binary data and C-style null-terminated strings. You will learn to detect, split, and remove null bytes safely.

Introduction

Most web text never contains a null character. But in systems programming, file parsing, and security hardening, the NUL byte still matters. The \0 escape lets your regex target that invisible code point directly.

In JavaScript strings, you can create a null character with "\0", "\u0000", or "\x00". In a regular expression, write /\0/ or the safer /\x00/ to match it.

Understanding the \0 Metacharacter

The null character marks the end of strings in C and appears in some binary formats. In JavaScript, strings can contain embedded nulls, and \0 in a regex matches exactly one such character.

/\0/.test("hello");           // false
/\0/.test("hello\u0000");    // true

"a\u0000b\u0000c".split(/\0/);     // ["a", "b", "c"]
"safe\u0000data".replace(/\0/g, ""); // "safedata"

Because null is invisible, use charCodeAt() or includes("\0") alongside regex when debugging.

How to Use \0 in JavaScript

Use \0 in detection, splitting, sanitization, and validation workflows:

/\0/.test(userInput);              // detect null bytes
text.split(/\0/);                  // split C-style segments
text.replace(/\x00/g, "");         // strip all nulls (safe form)
!/\0/.test(filename);              // reject filenames with NUL

Always use the global flag when removing every null byte with replace().

📝 Syntax

\0              // null character (NUL)
\x00            // same null byte (hex, safer in regex)
\u0000          // null in string literals
/\0/g           // global: every null byte
/\0+/           // one or more consecutive nulls

Common patterns

• /\0/ — detect whether any null byte exists.
• /\x00/g — remove all null characters from input.
• split(/\0/) — break a string at null terminators.
• /^(?!.*\0).*$/ — reject strings containing null.

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples cover detection, splitting, removal, validation, and escape-form comparison.

console.log(/\0/.test("hello"));        // false
console.log(/\0/.test("hello\u0000"));     // true
console.log(/\0/.test("a\u0000b"));       // true

false
true
true

const raw = "apple\u0000banana\u0000cherry";

const parts = raw.split(/\0/);
console.log(parts); // ["apple", "banana", "cherry"]

console.log(parts.length); // 3

["apple", "banana", "cherry"]
3

const dirty = "user\u0000name\u0000";

const clean = dirty.replace(/\x00/g, "");
console.log(clean);              // "username"
console.log(clean.length);       // 8

username
8

function isNullFree(value) {
  return !/\0/.test(value);
}

console.log(isNullFree("report.pdf"));       // true
console.log(isNullFree("doc\u0000.pdf"));     // false
console.log(isNullFree("hello"));            // true

true
false
true

const sample = "x\u0000y";

console.log(/\0/.test(sample));    // true
console.log(/\x00/.test(sample));  // true

console.log(sample.charCodeAt(1)); // 0 (NUL code point)

true
true
0

🚀 Common Use Cases

• Input sanitization — strip null bytes from user-provided strings before saving.
• Filename validation — reject paths containing NUL to avoid truncation issues.
• Binary parsing — split legacy null-delimited records with split(/\0/).
• Security checks — detect null-byte injection in uploaded content.
• Data migration — clean imported files that embed unexpected NUL characters.
• Debugging — locate invisible characters that break string comparisons.

Important Considerations

• Invisible character — null prints nothing; use charCodeAt() or length checks to debug.
• Octal ambiguity — \0 followed by digits may parse as octal; prefer \x00 in regex.
• Not whitespace — \0 is not matched by \s.
• Global flag — omitting g in replace() removes only the first null.
• Rare in web text — most UI strings never contain NUL; handle it mainly for security and binary edge cases.

📝 Notes

• \0, \x00, and \u0000 all represent the same null character.
• Null is U+0000 with numeric value 0 in charCodeAt().
• Review \n and other control-character metacharacters.
• Next up: \s whitespace metacharacter.
• Prefer /\x00/g over /\0/g when digits may follow in the pattern.
• Null bytes are invalid in many file systems and protocols—validate early.

💡 Best Practices