Я сделал наивный тест на node.js v6.0.0 и получил почти такую ​​же производительность. Поскольку тест настолько наивен, не верьте слишком большим числам. Но, похоже, компилятор JIT генерирует очень оптимизированный код в наши дни. Это позволяет мне выбирать предпочтительные шаблоны для конкатенации для моих приложений-узлов.

Для справки это код, который я использовал:

'use strict'

function strConcat(i) {
    return 'abc' + i + 'def'
}

function strTemplate(i) {
    return `abc${i}def`
}

function run(strategy) {
    let before = new Date().getTime()
    let len = 0
    for ( let i = 0; i < 10000000; i+=1 ) {
        len += strategy(i).length
    }
    console.log(len + ' - ' + ((new Date().getTime()) - before) + 'ms')
}

console.log('strConcat')
run(strConcat)

console.log('strTemplate')
run(strTemplate)

И выход был:

strConcat
128888890 - 1904ms
strTemplate
128888890 - 1979ms

Я использовал len, чтобы убедиться, что оптимизатор не оптимизирует весь цикл. Во всяком случае, это еще очень простой тест. Может быть, кто-то может сделать более сложный.

TL; DR

Конкатенация быстрее и более последовательна в отношении ее скорости. Но разница очень мало для 1 или 2 переменных (ниже 0,3 секунды для 100 миллионов вызовов).

Изменить

После второго запуска кажется, что конкатенация в основном быстрее два.

Итак, я хотел развернуть ответ analog-nico , предоставив тест, который был более обширным, а также немного посмотрел на масштабируемость двух функции.

Код на pastebin

Я решил использовать четыре тестовых примера для каждой функции, имеющую переменную спереди, одну в конце, одну в середине и две переменные в середине. Базовая установка такая же. Я просто использую 100 000 000 итераций функции, и эти итерации выполняются 100 раз. Я использовал те же механизмы для предотвращения оптимизации, а именно получения суммы длин результирующих строк и ведения журнала. Я также записал необходимое время (чтобы угадать, сколько времени это займет), но также сохранил его в массиве.

Впоследствии я вычислил среднее, минимальное, максимальное и стандартное отклонения для каждого метода .

Вот результаты:

{ 
  sum: { 
    t: { 
      start: 2072751, 
      mid: 2338476, 
      end: 2083695, 
      double: 2950287 
    },
    c: { 
      start: 2086059, 
      mid: 2345551, 
      end: 2074732, 
      double: 2922929 
    } 
  },
  avg: { 
    t: { 
      start: 20727.51,
      mid: 23384.76,
      end: 20836.95,
      double: 29502.87 
    },
    c: { 
      start: 20860.59,
      mid: 23455.51,
      end: 20747.32,
      double: 29229.29 
    } 
  },
  sd: {
    t: {
      start: 335.6251329981114,
      mid: 282.9490809315344,
      end: 286.2220947096852,
      double: 216.40844045461824 
    },
    c: {
      start: 255.4803356424913,
      mid: 221.48744862858484,
      end: 238.98242111084238,
      double: 209.9309074433776 
    } 
  },
  min: { 
    t: { 
      start: 20490, 
      mid: 23216, 
      end: 20588, 
      double: 29271 
    },
    c: { 
      start: 20660, 
      mid: 23258, 
      end: 20534, 
      double: 28985 
    } 
  },
  max: { 
    t: { 
      start: 23279, 
      mid: 25616, 
      end: 22887, 
      double: 30843 
    },
    c: { 
      start: 22603, 
      mid: 25062, 
      end: 22403, 
      double: 30536 
    } 
  } 
}

значения в t -объектах предназначены для шаблонов, значения в c -объектах предназначены для конкатенации. start означает, что переменная находится в начале, в середине, когда она находится посередине, заканчивая, что она находится в конце и в два раза, что есть две переменные. sum - сумма всех 100 прогонов. avg - средний пробег, то есть sum / 100. sd Вот простой выход, википедия (простой английский) . min и max являются минимальным и максимальным значением пробега соответственно.

Результаты

Кажется, что шаблоны быстрее для одиночных переменных, которые не расположены в конце строка, учитывая, что среднее значение меньше, а минимальное - ниже. Если вы помещаете переменную в конец строки или имеете несколько переменных в своей строке, конкатенация выполняется быстрее.

Хотя минимальное, а также среднее число шаблонов лучше, чем их сопоставления конкатенации в отношении первых двух условий, стандартное отклонение последовательно хуже. Разница, похоже, сокращается с большим количеством переменных (требуется больше тестов).

Так как большинство шаблонов, вероятно, не будут использоваться только для одной переменной в строке, это сохранить, чтобы сказать, что прилипание к конкатенации дает лучший представление. Но разница (по крайней мере на данный момент) очень незначительна. При 100 000 000 (100 миллионов) оценках с двумя переменными разница составляет всего 273,58 мс, примерно четверть секунды ...

Second Run

Второй запуск выглядит немного отличается. За исключением максимального значения, среднего абсолютного отклонения и стандартного отклонения, каждое измерение подтвердило, что конкатенация выполняется быстрее, чем шаблоны.

Три упомянутых измерения имели более низкие (тем самым лучшие) значения для шаблонов, когда переменная находилась на конец строки или когда в строке были две переменные.

Вот результаты:

{
  "sum": {
    "t": {
      "start": 1785103,
      "mid": 1826679,
      "end": 1719594,
      "double": 2110823,
      "many": 4153368
    },
    "c": {
      "start": 1720260,
      "mid": 1799579,
      "end": 1716883,
      "double": 2097473,
      "many": 3836265
    }
  },
  "avg": {
    "t": {
      "start": 17851.03,
      "mid": 18266.79,
      "end": 17195.94,
      "double": 21108.23,
      "many": 41533.68
    },
    "c": {
      "start": 17202.6,
      "mid": 17995.79,
      "end": 17168.83,
      "double": 20974.73,
      "many": 38362.65
    }
  },
  "sd": {
    "t": {
      "start": 858.7857061572462,
      "mid": 886.0941856823124,
      "end": 786.5366719994689,
      "double": 905.5376950188214,
      "many": 1744.9005638144542
    },
    "c": {
      "start": 599.0468429096342,
      "mid": 719.1084521127534,
      "end": 935.9367719563112,
      "double": 991.5642274204934,
      "many": 1465.1116774840066
    }
  },
  "aad": {
    "t": {
      "start": 579.1207999999996,
      "mid": 576.5628000000003,
      "end": 526.8268,
      "double": 586.9651999999998,
      "many": 1135.9432000000002
    },
    "c": {
      "start": 467.96399999999966,
      "mid": 443.09220000000016,
      "end": 551.1318000000008,
      "double": 610.2321999999999,
      "many": 1020.1310000000003
    }
  },
  "min": {
    "t": {
      "start": 16932,
      "mid": 17238,
      "end": 16387,
      "double": 20016,
      "many": 39327
    },
    "c": {
      "start": 16477,
      "mid": 17137,
      "end": 16226,
      "double": 19863,
      "many": 36424
    }
  },
  "max": {
    "t": {
      "start": 23310,
      "mid": 24102,
      "end": 21258,
      "double": 26883,
      "many": 49103
    },
    "c": {
      "start": 19328,
      "mid": 23203,
      "end": 22859,
      "double": 26875,
      "many": 44352
    }
  },
  "median": {
    "t": {
      "start": 17571,
      "mid": 18062,
      "end": 16974,
      "double": 20874,
      "many": 41171.5
    },
    "c": {
      "start": 16893.5,
      "mid": 18213,
      "end": 17016.5,
      "double": 20771,
      "many": 38849
    }
  }
}

Код здесь

Для простого теста со случайными числами как строки, оба приближаются так близко к Chrome & amp; FF

Тестирование в Chrome 58.0.3029 / Windows 10

Строковые литералы 2,996,883 ± 2,36% быстрее

Оператор (+) 3,054,078 ± 2,01% быстрее

Конкатентная функция 2,659,391 ± 2,35% 13% медленнее

Тестирование в Firefox 53.0.2 / Windows 10

Строковые литералы 1 923 835 ± 1,52% быстрее

Оператор (+) 1,948,503 ± 1,13% самый быстрый

Конкатентная функция 1,810,857 ± 1,81% 8% медленнее

Тест здесь, в jsperf