JavaScript String raw() Method

What You’ll Learn

String.raw() is a static tag function for template literals (same API as MDN String.raw()). Think of Python’s r"..." or C#’s @"...": ${} substitutions still run, but escapes like \n stay as text. Learn paths, regex patterns, identity-tag pitfalls, five examples, and try-it labs.

Introduction

In a normal template literal, `Hi\nthere` contains a real newline. With String.raw`Hi\nthere`, you get the characters H i \ n t h… — the backslash is preserved.

That makes Windows paths, regex sources, and other backslash-heavy text much easier to read. Substitutions still work: String.raw`Hi\n${name}!` inserts name, but keeps \n as two characters.

This page is part of JavaScript String Methods under Static Methods. Related topics include fromCharCode() and fromCodePoint().

Understanding the raw() Method

Template literals have a cooked form (escapes processed) and a raw form (escapes kept as written). String.raw builds the result from the raw pieces, then inserts evaluated substitutions between them.

• Usually used as a tag: String.raw`template`.
• Can also be called as a function with { raw: [...] } (advanced).
• It is the only built-in template tag in JavaScript.
• Not a true “identity” tag — escapes stay raw unless you pass cooked strings on purpose.

📝 Syntax

Two ways to call the static String.raw method (from MDN):

String.raw(strings)
String.raw(strings, sub1)
String.raw(strings, sub1, sub2)
String.raw(strings, sub1, sub2, /* …, */ subN)

String.raw`templateString`

Parameters

• strings — a well-formed template array object like { raw: ['foo', 'bar'] } (provided automatically when used as a tag).
• sub1 … subN — substitution values for ${...}.
• templateString — a template literal, optionally with substitutions.

Return value

The raw string form of the template (substitutions applied, escapes not).

Exceptions

TypeError if the first argument has no usable raw property.

Common patterns

String.raw`Hi\n${2 + 3}!`;
// 'Hi\\n5!'  — backslash + n, then 5

const path = String.raw`C:\Development\profile\about.html`;

const name = "Bob";
String.raw`Hi\n${name}!`;  // 'Hi\\nBob!'

// Advanced call shape:
String.raw({ raw: "test" }, 0, 1, 2); // "t0e1s2t"

Examples Gallery

Examples follow MDN String.raw() patterns. Use View Output or Try It Yourself for each case.

const filePath = String.raw`C:\Development\profile\about.html`;

console.log(`The file was uploaded from: ${filePath}`);
// The file was uploaded from: C:\Development\profile\about.html

The file was uploaded from: C:\Development\profile\about.html

JSON.stringify(String.raw`Hi\n${2 + 3}!`);
// "Hi\\n5!"

JSON.stringify(String.raw`Hi\u000A!`);
// "Hi\\u000A!"

String.raw`Hi\n!`.length;  // 5

"Hi\\n5!"
"Hi\\u000A!"
5

const name = "Bob";

JSON.stringify(String.raw`Hi\n${name}!`);
// "Hi\\nBob!"

// Insert a literal ${name} using a substitution:
JSON.stringify(String.raw`Hi ${"$"}{name}!`);
// "Hi ${name}!"

"Hi\\nBob!"
"Hi ${name}!"

const re = new RegExp(
  String.raw`https://developer\.mozilla\.org/en-US/docs/Web/JavaScript/Reference/`
);

re.test(
  "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/"
); // true

function makeURLRegExp(path) {
  return new RegExp(String.raw`https://developer\.mozilla\.org/${path}`);
}

makeURLRegExp(".*").test("https://developer.mozilla.org/anything"); // true

true
true

JSON.stringify(String.raw`\n`);
// "\\n"  — still raw

const html = (strings, ...values) =>
  String.raw({ raw: strings }, ...values);

JSON.stringify(html`\n`);
// "\n"  — newline cooked

String.raw({ raw: "test" }, 0, 1, 2);
// "t0e1s2t"

"<canvas>\\n</canvas>"
"<canvas>\n</canvas>"
t0e1s2t

🚀 Common Use Cases

• File / Windows paths — avoid doubling every backslash.
• RegExp constructors — readable patterns with dynamic pieces.
• URLs and slash-heavy text — fewer escaping mistakes.
• Debugging templates — inspect the raw form of escapes.
• Custom tags — reuse String.raw({ raw: ... }) when building helpers.
• Not for cooked HTML newlines — use a real identity tag if \n must become a break.

📝 Notes

• Always use the tag form String.raw`...` for everyday work.
• Substitutions run; escapes do not.
• A trailing single \ before the closing backtick can break the template — use ${"\\"} for a final backslash.
• Do not use bare String.raw as an HTML identity tag if you need cooked escapes.
• Related static helpers: fromCharCode(), fromCodePoint().
• Continue with the String constructor.

💡 Best Practices