How can I do string interpolation in JavaScript?

The Question :

597 people think this question is useful

Consider this code:

var age = 3;

console.log("I'm " + age + " years old!");

Are there any other ways to insert the value of a variable in to a string, apart from string concatenation?

The Question Comments :
  • You could checkout CoffeeScript:
  • As others have indicated, the method you are using is the easiest way to go about it. I would love to be able to refer to variables inside strings, but in javascript you need to use concatenation (or some other find/replace approach). Folks like you and I are probably just a little too attached to PHP for our own good.
  • Use Underscore.js template
  • Concatenation is not interpolation and the user asked how to do interpolation. I think Lev finally provided the answer, i.e. there is no way to do this in native JS. I do not understand why this not a real question.
  • If I could be allowed to answer, there is now a solution starting for newer interpretters (2015 FF and Chrome already support):… . Eg. Show GRAPH of : ${fundCode}-${funcCode} gets me Show GRAPH of : AIP001-_sma (use backticks around string 1….cannot seem to display here)

The Answer 1

625 people think this answer is useful

Since ES6, you can use template literals:

const age = 3
console.log(`I'm ${age} years old!`)

P.S. Note the use of backticks: ``.

The Answer 2

242 people think this answer is useful


Use ECMAScript 2015’s Template String Literals, if applicable.


There is no direct way to do it, as per ECMAScript 5 specifications, but ECMAScript 6 has template strings, which were also known as quasi-literals during the drafting of the spec. Use them like this:

> var n = 42;
> `foo${n}bar`

You can use any valid JavaScript expression inside the {}. For example:

> `foo${{name: 'Google'}.name}bar`
> `foo${1 + 3}bar`

The other important thing is, you don’t have to worry about multi-line strings anymore. You can write them simply as

> `foo
...     bar`
'foo\n    bar'

Note: I used io.js v2.4.0 to evaluate all the template strings shown above. You can also use the latest Chrome to test the above shown examples.

Note: ES6 Specifications are now finalized, but have yet to be implemented by all major browsers.
According to the Mozilla Developer Network pages, this will be implemented for basic support starting in the following versions: Firefox 34, Chrome 41, Internet Explorer 12. If you’re an Opera, Safari, or Internet Explorer user and are curious about this now, this test bed can be used to play around until everyone gets support for this.

The Answer 3

196 people think this answer is useful

Douglas Crockford’s Remedial JavaScript includes a String.prototype.supplant function. It is short, familiar, and easy to use:

String.prototype.supplant = function (o) {
    return this.replace(/{([^{}]*)}/g,
        function (a, b) {
            var r = o[b];
            return typeof r === 'string' || typeof r === 'number' ? r : a;

// Usage:
alert("I'm {age} years old!".supplant({ age: 29 }));
alert("The {a} says {n}, {n}, {n}!".supplant({ a: 'cow', n: 'moo' }));

If you don’t want to change String’s prototype, you can always adapt it to be standalone, or place it into some other namespace, or whatever.

The Answer 4

55 people think this answer is useful

Word of caution: avoid any template system which does’t allow you to escape its own delimiters. For example, There would be no way to output the following using the supplant() method mentioned here.

“I am 3 years old thanks to my {age} variable.”

Simple interpolation may work for small self-contained scripts, but often comes with this design flaw that will limit any serious use. I honestly prefer DOM templates, such as:

<div> I am <span id="age"></span> years old!</div>

And use jQuery manipulation: $('#age').text(3)

Alternately, if you are simply just tired of string concatenation, there’s always alternate syntax:

var age = 3;
var str = ["I'm only", age, "years old"].join(" ");

The Answer 5

27 people think this answer is useful

I use this pattern in a lot of languages when I don’t know how to do it properly yet and just want to get an idea down quickly:

// JavaScript
let stringValue = 'Hello, my name is {name}. You {action} my {relation}.'
    .replace(/{name}/g    ,'Indigo Montoya')
    .replace(/{action}/g  ,'killed')

While not particularily efficient, I find it readable. It always works, and its always available:

' VBScript
dim template = "Hello, my name is {name}. You {action} my {relation}."
dim stringvalue = template
stringValue = replace(stringvalue, "{name}"    ,"Luke Skywalker")     
stringValue = replace(stringvalue, "{relation}","Father")     
stringValue = replace(stringvalue, "{action}"  ,"are")


INSPECT stringvalue REPLACING FIRST '{name}'     BY 'Grendel'
INSPECT stringvalue REPLACING FIRST '{relation}' BY 'Mother'
INSPECT stringvalue REPLACING FIRST '{action}'   BY 'did unspeakable things to'

The Answer 6

23 people think this answer is useful

You could use Prototype’s template system if you really feel like using a sledgehammer to crack a nut:

var template = new Template("I'm #{age} years old!");
alert(template.evaluate({age: 21}));

The Answer 7

23 people think this answer is useful

Try sprintf library (a complete open source JavaScript sprintf implementation). For example:

vsprintf('The first 4 letters of the english alphabet are: %s, %s, %s and %s', ['a', 'b', 'c', 'd']);

vsprintf takes an array of arguments and returns a formatted string.

The Answer 8

12 people think this answer is useful

You can do easily using ES6 template string and transpile to ES5 using any available transpilar like babel.

const age = 3;

console.log(`I'm ${age} years old!`);

The Answer 9

8 people think this answer is useful

If you want to interpolate in console.log output, then just

console.log("Eruption 1: %s", eruption1);

Here, %s is what is called a “format specifier”. console.log has this sort of interpolation support built-in.

The Answer 10

6 people think this answer is useful

Try kiwi, a light-weight JavaScript module for string interpolation.

You can do

Kiwi.compose("I'm % years old!", [age]);


Kiwi.compose("I'm %{age} years old!", {"age" : age});

The Answer 11

6 people think this answer is useful

Here’s a solution which requires you to provide an object with the values. If you don’t provide an object as parameter, it will default to using global variables. But better stick to using the parameter, it’s much cleaner.

String.prototype.interpolate = function(props) {
    return this.replace(/\{(\w+)\}/g, function(match, expr) {
        return (props || window)[expr];

// Test:

// Using the parameter (advised approach)
document.getElementById("resultA").innerText = "Eruption 1: {eruption1}".interpolate({ eruption1: 112 });

// Using the global scope
var eruption2 = 116;
document.getElementById("resultB").innerText = "Eruption 2: {eruption2}".interpolate();
<div id="resultA"></div><div id="resultB"></div>

The Answer 12

2 people think this answer is useful

Expanding on Greg Kindel’s second answer, you can write a function to eliminate some of the boilerplate:

var fmt = {
    join: function() {
        return' ');
    log: function() {


var age = 7;
var years = 5;
var sentence = fmt.join('I am now', age, 'years old!');
fmt.log('In', years, 'years I will be', age + years, 'years old!');

The Answer 13

2 people think this answer is useful

I can show you with an example:

function fullName(first, last) {
  let fullName = first + " " + last;
  return fullName;

function fullNameStringInterpolation(first, last) {
  let fullName = `${first} ${last}`;
  return fullName;

console.log('Old School: ' + fullName('Carlos', 'Gutierrez'));

console.log('New School: ' + fullNameStringInterpolation('Carlos', 'Gutierrez'));

The Answer 14

1 people think this answer is useful

Since ES6, if you want to do string interpolation in object keys, you will get a SyntaxError: expected property name, got '${' if you do something like:

let age = 3
let obj = { `${age}`: 3 }

You should do the following instead:

let obj = { [`${age}`]: 3 }

The Answer 15

1 people think this answer is useful

Supplant more for ES6 version of @Chris Nielsen’s post.

String.prototype.supplant = function (o) {
  return this.replace(/\${([^\${}]*)}/g,
    (a, b) => {
      var r = o[b];
      return typeof r === 'string' || typeof r === 'number' ? r : a;

string = "How now ${color} cow? {${greeting}}, ${greeting}, moo says the ${color} cow.";

string.supplant({color: "brown", greeting: "moo"});
=> "How now brown cow? {moo}, moo, moo says the brown cow."

The Answer 16

1 people think this answer is useful

Couldn’t find what I was looking for, then found it –

If you’re using Node.js, there’s a built-in utilpackage with a format function that works like this:

util.format("Hello my name is %s", "Brent");
> Hello my name is Brent

Coincidentally this is now built into console.log flavors too in Node.js –

console.log("This really bad error happened: %s", "ReferenceError");
> This really bad error happened: ReferenceError

The Answer 17

0 people think this answer is useful

Using template syntax fails in older browsers, important if you are creating HTML for public use. Using concatenation is tedious and hard to read, particularly if you have many or long expressions, or if you must use parentheses to handle mixtures of number and string items (both of which use the + operator).

PHP expands quoted strings containing variables and even some expressions using a very compact notation: $a="the color is $color";

In JavaScript, an efficient function can be written to support this: var a=S('the color is ',color);, using a variable number of arguments. While there is no advantage over concatenation in this example, when the expressions get longer this syntax may be clearer. Or one can use the dollar sign to signal the start of an expression using a JavaScript function, as in PHP.

On the other hand, writing an efficient workaround function to provide template-like expansion of strings for older browsers wouldn’t be hard. Someone has probably done it already.

Finally, I imagine that sprintf (as in C, C++, and PHP) could be written in JavaScript, although it would be a little less efficient than these other solutions.

The Answer 18

0 people think this answer is useful

Custom flexible interpolation:

var sourceElm = document.querySelector('input')

// interpolation callback
const onInterpolate = s => `<mark>${s}</mark>`

// listen to "input" event
sourceElm.addEventListener('input', parseInput) 

// parse on window load

// input element parser
function parseInput(){
  var html = interpolate(sourceElm.value, undefined, onInterpolate)
  sourceElm.nextElementSibling.innerHTML = html;

// the actual interpolation 
function interpolate(str, interpolator = ["{{", "}}"], cb){
  // split by "start" pattern
  return str.split(interpolator[0]).map((s1, i) => {
    // first item can be safely ignored
	  if( i == 0 ) return s1;
    // for each splited part, split again by "end" pattern 
    const s2 = s1.split(interpolator[1]);

    // is there's no "closing" match to this part, rebuild it
    if( s1 == s2[0]) return interpolator[0] + s2[0]
    // if this split's result as multiple items' array, it means the first item is between the patterns
    if( s2.length > 1 ){
        s2[0] = s2[0] 
          ? cb(s2[0]) // replace the array item with whatever
          : interpolator.join('') // nothing was between the interpolation pattern

    return s2.join('') // merge splited array (part2)
  }).join('') // merge everything 
  width: 100%; 
  box-sizing: border-box;
  margin-bottom: 20px;

  font: 14px Arial;
<input value="Everything between {{}} is {{processed}}" />

The Answer 19

0 people think this answer is useful

While templates are probably best for the case you describe, if you have or want your data and/or arguments in iterable/array form, you can use String.raw.

  raw: ["I'm ", " years old!"]
}, 3);

With the data as an array, one can use the spread operator:

const args = [3, 'yesterday'];
  raw: ["I'm ", " years old as of ", ""]
}, ...args);

Add a Comment