使用 ES6，您可以使用

• 模板字符串：

  var username = 'craig';
  console.log(`hello ${username}`);
  

ES5及以下：

• 使用+运算符

  var username = 'craig';
  var joined = 'hello ' + username;
  

• 字符串的 concat(..)

  var username = 'craig';
  var joined = 'hello '.concat(username);
  

或者，使用数组方法：

• join(..)：

  var username = 'craig';
  var joined = ['hello', username].join(' ');
  

• 甚至更高级，reduce(..)结合以上任何一项：

  var a = ['hello', 'world', 'and', 'the', 'milky', 'way'];
  var b = a.reduce(function(pre, next) {
    return pre + ' ' + next;
  });
  console.log(b); // hello world and the milky way
  

我很失望其他答案中没有人将“最佳方式”解释为“最快方式”......

我从这里提取了 2 个示例，str.join()并str.reduce()从上面nishanths 的回答中添加了和。这是我在 Linux 上的 Firefox 77.0.1 上的结果。

注意：我在测试这些时发现，如果我将str = str.concat()和str +=直接放在彼此之前或之后，第二个总是表现得更好......所以我单独运行这些测试并评论其他结果......

尽管如此，如果我重新运行它们，它们的速度差异很大，所以我为每个测量了 3 次。

一次 1 个字符：

• str = str.concat()： 841, 439, 956 ms / 1e7 concat()'s
• ............str +=： 949, 1130, 664 ms / 1e7 +='s
• .........[].join()： 3350, 2911, 3522 ms / 1e7 characters in []
• .......[].reduce()： 3954, 4228, 4547 ms / 1e7 characters in []

一次 26 个字符串：

• str = str.concat()： 444, 744, 479 ms / 1e7 concat()'s
• ............str +=： 1037, 473, 875 ms / 1e7 +='s
• .........[].join()： 2693, 3394, 3457 ms / 1e7 strings in []
• .......[].reduce()： 2782, 2770, 4520 ms / 1e7 strings in []

因此，无论是一次附加 1 个字符还是一次 26 个字符串：

• 明显的赢家：基本上是str = str.concat()和之间的平局str +=
• 清除失败者：[].reduce()，其次是[].join()

我的代码，易于在浏览器控制台中运行：

{
  console.clear();

  let concatMe = 'a';
  //let concatMe = 'abcdefghijklmnopqrstuvwxyz';

  //[].join()
  {
    s = performance.now();
    let str = '', sArr = [];
    for (let i = 1e7; i > 0; --i) {
      sArr[i] = concatMe;
    }
    str = sArr.join('');
    e = performance.now();
    console.log(e - s);
    console.log('[].join(): ' + str);
  }

  //str +=
  {
    s = performance.now();
    let str = '';
    for (let i = 1e7; i > 0; --i) {
      str += concatMe;
    }
    e = performance.now();
    console.log(e - s);
    console.log('str +=: ' + str);
  }

  //[].reduce()
  {
    s = performance.now();
    let str = '', sArr = [];
    for (let i = 1e7; i > 0; --i) {
      sArr[i] = concatMe;
    }
    str = sArr.reduce(function(pre, next) {
      return pre + next;
    });
    e = performance.now();
    console.log(e - s);
    console.log('[].reduce(): ' + str);
  }

  //str = str.concat()
  {
    s = performance.now();
    let str = '';
    for (let i = 1e7; i > 0; --i) {
      str = str.concat(concatMe);
    }
    e = performance.now();
    console.log(e - s);
    console.log('str = str.concat(): ' + str);
  }

  'Done';
}

var descriptor = 'awesome';
console.log(`ES6 is ${descriptor}!`);

更多：https : //developers.google.com/web/updates/2015/01/ES6-Template-Strings?hl=en

我认为replace()在这里值得一提。

在某些情况下，replace 方法在构建字符串时可以很好地为您服务。具体来说，显然，当您将动态部分注入其他静态字符串时。例子：

var s = 'I am {0} today!';
var result = s.replace('{0}', 'hungry');
// result: 'I am hungry today!'

要替换的占位符显然可以是任何东西。我出于 C# 的习惯使用“{0}”、“{1}”等。它只需要足够独特，不会出现在预期之外的字符串中。

因此，如果我们可以稍微处理一下字符串部分，OP 示例也可以这样解决：

var x = 'Hello {0}';
var y = 'World';
var result = x.replace('{0}', y);
// result: 'Hello World'. -Oh the magic of computing!

“替换”参考：https : //www.w3schools.com/jsreF/jsref_replace.asp

您可以使用该concat功能。

var hello = "Hello ";
var world = "world!";
var res = hello.concat(world);