Examples

This page provides practical, runnable code examples for integrating ansi-regex into your Node.js applications. You'll see how to generate the ANSI escape code regular expression, use it to detect ANSI sequences in strings, and apply it to real-world scenarios like stripping color codes from terminal output. These examples build on one another, so reading them in order will give you a solid foundation for using the library effectively.

Before working through these examples, make sure you have the following:

• Node.js installed (any actively maintained LTS version)
• npm or yarn available in your terminal
• Basic familiarity with JavaScript RegExp methods (.test(), .match(), .replace())
• ansi-regex installed in your project (see the Installation section below)

1. Navigate to your project directory in your terminal.

2. Install ansi-regex using npm:

npm install ansi-regex

Or, if you prefer yarn:

yarn add ansi-regex

3. Verify the installation by checking your node_modules directory or running:

node -e "require('ansi-regex'); console.log('ansi-regex installed successfully')"

ansi-regex exposes a single factory function that you call with no arguments. It has no external configuration options or constructor parameters — calling the function always returns a freshly constructed RegExp object with the global (g) flag set.

Because a new RegExp instance is returned on every invocation, you avoid the pitfall of the global flag's lastIndex state carrying over between unrelated operations. If you plan to call .test() or .exec() in a loop against the same string, always call ansiRegex() fresh rather than reusing a single instance.

Import the library and call ansiRegex() to obtain the regular expression, then use standard JavaScript RegExp methods against your strings.

Import the module

'use strict';
const ansiRegex = require('ansi-regex');

Generate the regex

const regex = ansiRegex();
// regex is a RegExp with the global flag

Test whether a string contains ANSI codes

Use .test() when you only need a boolean answer:

const hasAnsi = ansiRegex().test('\u001B[4mUnderline\u001B[0m');
// true

Find all ANSI sequences in a string

Use .match() to collect every escape sequence present:

const sequences = '\u001B[4mHello\u001B[0m'.match(ansiRegex());
// ['\u001B[4m', '\u001B[0m']

Strip ANSI codes from a string

Replace every matched sequence with an empty string to get plain text:

const plain = '\u001B[4mHello\u001B[0m'.replace(ansiRegex(), '');
// 'Hello'

Example 1 — Detecting ANSI escape codes

Check whether a string coming from a terminal or log file contains any ANSI sequences before processing it.

'use strict';
const ansiRegex = require('ansi-regex');

const rawOutput = '\u001B[32mSUCCESS\u001B[0m: build complete';

if (ansiRegex().test(rawOutput)) {
  console.log('String contains ANSI escape codes.');
} else {
  console.log('String is plain text.');
}

Expected output:

String contains ANSI escape codes.

Example 2 — Extracting all ANSI sequences from a string

Collect every escape sequence present so you can inspect or log them.

'use strict';
const ansiRegex = require('ansi-regex');

const coloredText = '\u001B[1m\u001B[33mWarning:\u001B[0m disk usage above 90%';
const sequences = coloredText.match(ansiRegex());

console.log(sequences);

Expected output:

[ '\u001B[1m', '\u001B[33m', '\u001B[0m' ]

Example 3 — Stripping ANSI codes to produce plain text

Remove all escape sequences before writing output to a plain-text log file or comparing strings in tests.

'use strict';
const ansiRegex = require('ansi-regex');

const styledMessage = '\u001B[4m\u001B[31mERROR\u001B[0m: file not found';
const plainMessage = styledMessage.replace(ansiRegex(), '');

console.log(plainMessage);

Expected output:

ERROR: file not found

Example 4 — Processing multiple strings safely

Because ansiRegex() returns a fresh instance each time, you can safely test multiple strings without worrying about lastIndex state.

'use strict';
const ansiRegex = require('ansi-regex');

const lines = [
  '\u001B[32mOK\u001B[0m',
  'No ANSI here',
  '\u001B[31mFAIL\u001B[0m'
];

lines.forEach(line => {
  // Call ansiRegex() inside the loop for a fresh regex each iteration
  const stripped = line.replace(ansiRegex(), '');
  console.log(stripped);
});

Expected output:

OK
No ANSI here
FAIL

Issue 1 — .test() returns false for every string after the first match

Symptom: You store the result of ansiRegex() in a variable and call .test() on it multiple times; after the first true result, subsequent calls return false even on strings that clearly contain ANSI codes.

Cause: JavaScript RegExp objects with the global (g) flag maintain a lastIndex property. After a successful .test() call, lastIndex advances to the position after the match. On the next call against a different string, the search starts from that stale offset and may miss all sequences.

Fix: Call ansiRegex() inside your loop or function so you always get a fresh instance with lastIndex at 0:

// ❌ Problematic — reusing a single instance
const regex = ansiRegex();
strings.forEach(s => console.log(regex.test(s)));

// ✅ Correct — fresh instance per call
strings.forEach(s => console.log(ansiRegex().test(s)));

Issue 2 — require('ansi-regex') throws Cannot find module

Symptom: Your application throws Error: Cannot find module 'ansi-regex' at startup.

Cause: The package has not been installed in the current project, or you are running Node.js from a different working directory than where you ran npm install.

Fix: Run npm install ansi-regex from the root of your project (the directory containing package.json), then retry.

Issue 3 — .replace() only removes the first ANSI sequence

Symptom: After calling .replace(ansiRegex(), ''), some ANSI sequences remain in the output string.

Cause: This should not happen with ansiRegex() because the returned regex always has the global (g) flag. If you are seeing partial replacement, you may be using a manually constructed regex without the g flag.

Fix: Always use ansiRegex() rather than a hand-rolled pattern, and verify the flag:

console.log(ansiRegex().flags); // 'g'

Issue 4 — Plain text strings unexpectedly match the regex

Symptom: ansiRegex().test(str) returns true for a string you believe contains no ANSI codes.

Cause: The string may contain the ESC character (\u001B) or another control character that is not visible when printed but is present in the raw data (for example, copy-pasted from a terminal).

Fix: Inspect the raw character codes to confirm:

const codes = [...str].map(c => c.codePointAt(0).toString(16));
console.log(codes);

If 1b (ESC) or 9b (CSI) appears in the output, the string does contain ANSI sequences.