Template literals are string literals allowing embedded expressions. You can use multi-line strings and string interpolation features with them. They were called "template strings" in prior editions of the ES2015 / ES6 specification.
Syntax
`string text`
`string text line 1
string text line 2`
`string text ${expression} string text`
tag `string text ${expression} string text`
Description
Template literals are enclosed by the back-tick (` `) (grave accent) character instead of double or single quotes. Template literals can contain place holders. These are indicated by the Dollar sign and curly braces (${expression}). The expressions in the place holders and the text between them get passed to a function. The default function just concatenates the parts into a single string. If there is an expression preceding the template literal (tag here), the template string is called "tagged template literal". In that case, the tag expression (usually a function) gets called with the processed template literal, which you can then manipulate before outputting.
Multi-line strings
Any new line characters inserted in the source are part of the template literal. Using normal strings, you would have to use the following syntax in order to get multi-line strings:
console.log("string text line 1\n"+
"string text line 2");
// "string text line 1
// string text line 2"
To get the same effect with multi-line strings, you can now write:
console.log(`string text line 1 string text line 2`); // "string text line 1 // string text line 2"
Expression interpolation
In order to embed expressions within normal strings, you would use the following syntax:
var a = 5;
var b = 10;
console.log("Fifteen is " + (a + b) + " and\nnot " + (2 * a + b) + ".");
// "Fifteen is 15 and
// not 20."
Now, with template literals, you are able to make use of the syntactic sugar making substitutions like this more readable:
var a = 5;
var b = 10;
console.log(`Fifteen is ${a + b} and\nnot ${2 * a + b}.`);
// "Fifteen is 15 and
// not 20."
Tagged template literals
A more advanced form of template literals are tagged template literals. With them you are able to modify the output of template literals using a function. The first argument contains an array of string literals ("Hello " and " world" in this example). The second, and each argument after the first one, are the values of the processed (or sometimes called cooked) substitution expressions ("15" and "50" here). In the end, your function returns your manipulated string. There is nothing special about the name tag in the following example. The function name may be anything you want.
var a = 5;
var b = 10;
function tag(strings, ...values) {
console.log(strings[0]); // "Hello "
console.log(strings[1]); // " world "
console.log(values[0]); // 15
console.log(values[1]); // 50
return "Bazinga!";
}
tag`Hello ${ a + b } world ${ a * b }`;
// "Bazinga!"
Tag functions need not return a string, as shown in the following example.
function template(strings, ...keys) {
return (function(...values) {
var dict = values[values.length - 1] || {};
var result = [strings[0]];
keys.forEach(function(key, i) {
var value = Number.isInteger(key) ? values[key] : dict[key];
result.push(value, strings[i + 1]);
});
return result.join('');
});
}
var t1Closure = template`${0}${1}${0}!`;
t1Closure('Y', 'A'); // "YAY!"
var t2Closure = template`${0} ${'foo'}!`;
t2Closure('Hello', {foo: 'World'}); // "Hello World!"
Raw strings
The special raw property, available on the first function argument of tagged template literals, allows you to access the raw strings as they were entered.
function tag(strings, ...values) {
console.log(strings.raw[0]);
// "string text line 1 \\n string text line 2"
}
tag`string text line 1 \n string text line 2`;
In addition, the {{jsxref("String.raw()")}} method exists to create raw strings just like the default template function and string concatenation would create.
String.raw`Hi\n${2+3}!`;
// "Hi\n5!"
Specifications
| Specification | Status | Comment |
|---|---|---|
| {{SpecName('ES6', '#sec-template-literals', 'Template Literals')}} | {{Spec2('ES6')}} | Initial definition. Defined in several section of the specification: Template Literals, Tagged Templates |
| {{SpecName('ESDraft', '#sec-template-literals', 'Template Literals')}} | {{Spec2('ESDraft')}} | Defined in several section of the specification: Template Literals, Tagged Templates |
Browser compatibility
| Feature | Chrome | Edge | Firefox (Gecko) | Internet Explorer | Opera | Safari |
|---|---|---|---|---|---|---|
| Basic support | {{CompatChrome(41)}} | {{CompatVersionUnknown}} | {{CompatGeckoDesktop("34")}} | {{CompatNo}} | {{CompatOpera(28)}} | {{CompatSafari(9)}} |
| Feature | Android | Chrome for Android | Firefox Mobile (Gecko) | IE Mobile | Opera Mobile | Safari Mobile |
|---|---|---|---|---|---|---|
| Basic support | {{CompatNo}} | {{CompatChrome(41)}} | {{CompatGeckoMobile("34")}} | {{CompatNo}} | {{CompatOpera(28)}} | {{CompatSafari(9)}} |
See also
- {{jsxref("String")}}
- {{jsxref("String.raw()")}}
- Lexical grammar
- Template-like strings in ES3 compatible syntax
- "ES6 in Depth: Template strings" on hacks.mozilla.org