要在指定次数内重复一个字符串，可以使用JavaScript中内置的repeat()方法。

下面是一个重复以下字符串4次的例子:

const name = "king";

const repeat = name.repeat(4);

console.log(repeat);

输出:

"kingkingkingking"

或者我们可以创建自己版本的repeat()函数，如下所示:

function repeat(str, n) {
  if (!str || !n) {
    return;
  }

 let final = "";
  while (n) {
    final += s;
    n--;
  }
  return final;
}

console.log(repeat("king", 3))

(最初发布于https://reactgo.com/javascript-repeat-string/)

disfated的答案提高了5-7%。

通过在计数> 1处停止来展开循环，并在循环之后执行额外的result += pattnern concat。这将避免循环最终使用以前未使用的模式+=模式，而不必使用昂贵的if检查。 最终的结果是这样的:

String.prototype.repeat = function(count) {
    if (count < 1) return '';
    var result = '', pattern = this.valueOf();
    while (count > 1) {
        if (count & 1) result += pattern;
        count >>= 1, pattern += pattern;
    }
    result += pattern;
    return result;
};

下面是disfate的小提琴分叉的展开版本:http://jsfiddle.net/wsdfg/

简单的递归连接

我只是想试一试，然后做了这个:

function ditto( s, r, c ) {
    return c-- ? ditto( s, r += s, c ) : r;
}

ditto( "foo", "", 128 );

我不能说我想得太多，它可能表明:-)

可以说这样更好

String.prototype.ditto = function( c ) {
    return --c ? this + this.ditto( c ) : this;
};

"foo".ditto( 128 );

这很像已经发布的答案-我知道。

但为什么要递归呢?

还有一点默认行为呢?

String.prototype.ditto = function() {
    var c = Number( arguments[ 0 ] ) || 2,
        r = this.valueOf();
    while ( --c ) {
        r += this;
    }
    return r;
}

"foo".ditto();

因为，尽管非递归方法将处理任意大的重复而不达到调用堆栈限制，但它要慢得多。

为什么我要费心添加更多的方法，而这些方法还不及已经发布的那些方法的一半聪明呢?

一部分是为了自娱自乐，一部分是为了用最简单的方式指出，我知道剥猫皮的方法有很多种，根据具体情况，显然最好的方法很可能并不理想。

一个相对快速和复杂的方法可能会在某些情况下有效地崩溃和烧毁，而一个更慢，更简单的方法可能最终会完成工作。

有些方法可能只是利用漏洞，因此很容易被修复而不复存在，而其他方法可能在所有条件下都工作得很好，但构造得太复杂，以至于人们根本不知道它是如何工作的。

“就算我不知道它是怎么工作的又怎样?!”

严重吗?

JavaScript有一个最大的优势;它对不良行为具有高度的容忍度，而且非常灵活，它会竭尽全力地返回结果，而如果它崩溃了，可能对每个人都更好!

“能力越大，责任越大”;-)

但更严肃和重要的是，尽管像这样的一般问题确实会以聪明的答案形式带来令人生畏的东西，如果没有其他的话，扩展了一个人的知识和视野，最终，手头的任务-使用结果方法的实际脚本-可能需要比建议的更少或更聪明一点。

这些“完美”的算法很有趣，但“一刀切”很少会比量身定制更好。

这篇布道是由于你睡眠不足和一时兴趣所致。 开始编码吧!

要在指定次数内重复一个字符串，可以使用JavaScript中内置的repeat()方法。

下面是一个重复以下字符串4次的例子:

const name = "king";

const repeat = name.repeat(4);

console.log(repeat);

输出:

"kingkingkingking"

或者我们可以创建自己版本的repeat()函数，如下所示:

function repeat(str, n) {
  if (!str || !n) {
    return;
  }

 let final = "";
  while (n) {
    final += s;
    n--;
  }
  return final;
}

console.log(repeat("king", 3))

(最初发布于https://reactgo.com/javascript-repeat-string/)

我随机来到这里，从来没有理由在javascript中重复字符。

我对artistoex的做法印象深刻，对结果感到失望。我注意到最后一个串连接是不必要的，正如丹尼斯也指出的那样。

我注意到一些更多的东西，当玩抽样disfate放在一起。

The results varied a fair amount often favoring the last run and similar algorithms would often jockey for position. One of the things I changed was instead of using the JSLitmus generated count as the seed for the calls; as count was generated different for the various methods, I put in an index. This made the thing much more reliable. I then looked at ensuring that varying sized strings were passed to the functions. This prevented some of the variations I saw, where some algorithms did better at the single chars or smaller strings. However the top 3 methods all did well regardless of the string size.

分叉测试集

http://jsfiddle.net/schmide/fCqp3/134/

// repeated string
var string = '0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789';
// count paremeter is changed on every test iteration, limit it's maximum value here
var maxCount = 200;

var n = 0;
$.each(tests, function (name) {
    var fn = tests[name];
    JSLitmus.test(++n + '. ' + name, function (count) {
        var index = 0;
        while (count--) {
            fn.call(string.slice(0, index % string.length), index % maxCount);
            index++;
        }
    });
    if (fn.call('>', 10).length !== 10) $('body').prepend('<h1>Error in "' + name + '"</h1>');
});

JSLitmus.runAll();

然后我加入了丹尼斯的解决方案，并决定看看我是否能找到更多的方法。

由于javascript不能真正优化，提高性能的最好方法是手动避免一些东西。如果我把前4个琐碎的结果从循环中取出，我可以避免2-4个字符串存储，并将最后的存储直接写入结果。

// final: growing pattern + prototypejs check (count < 1)
'final avoid': function (count) {
    if (!count) return '';
    if (count == 1) return this.valueOf();
    var pattern = this.valueOf();
    if (count == 2) return pattern + pattern;
    if (count == 3) return pattern + pattern + pattern;
    var result;
    if (count & 1) result = pattern;
    else result = '';
    count >>= 1;
    do {
        pattern += pattern;
        if (count & 1) result += pattern;
        count >>= 1;
    } while (count > 1);
    return result + pattern + pattern;
}

这比丹尼斯的修复方案平均提高了1-2%。然而，不同的运行和不同的浏览器会显示相当大的差异，这额外的代码可能不值得在前面的两种算法上付出努力。

一个图表

编辑:我这样做主要是在chrome浏览器。Firefox和IE通常对Dennis的偏爱程度为百分之几。

好消息!String.prototype.repeat现在是JavaScript的一部分。

"yo".repeat(2);
// returns: "yoyo"

除Internet Explorer外，所有主流浏览器都支持该方法。有关最新列表，请参见MDN: String.prototype.repeat >浏览器兼容性。

MDN为没有支持的浏览器提供了一个填充。