celui-ci est assez efficace

String.prototype.repeat = function(times){
    var result="";
    var pattern=this;
    while (times > 0) {
        if (times&1)
            result+=pattern;
        times>>=1;
        pattern+=pattern;
    }
    return result;
};

bonne nouvelle! String.prototype.repeat est accepté pour l'Harmonie (ECMAScript 6) .

> "yo".repeat(2)
"yoyo"

la méthode est disponible dans les versions récentes de V8, utilisé par noeud.js, Chrome ( String.repeat supporté depuis la version 41) et Opera. Les nouvelles versions de Safari et de Firefox semblent aussi avoir un support, mais Internet Explorer ne l'a pas. Pour une liste à jour, voir MDN: String.prototype.répéter > compatibilité avec le navigateur .

MDN propose polyfill:

if (!String.prototype.repeat) {
  String.prototype.repeat = function(count) {
    'use strict';
    if (this == null) {
      throw new TypeError('can\'t convert ' + this + ' to object');
    }
    var str = '' + this;
    count = +count;
    if (count != count) {
      count = 0;
    }
    if (count < 0) {
      throw new RangeError('repeat count must be non-negative');
    }
    if (count == Infinity) {
      throw new RangeError('repeat count must be less than infinity');
    }
    count = Math.floor(count);
    if (str.length == 0 || count == 0) {
      return '';
    }
    // Ensuring count is a 31-bit integer allows us to heavily optimize the
    // main part. But anyway, most current (August 2014) browsers can't handle
    // strings 1 << 28 chars or longer, so:
    if (str.length * count >= 1 << 28) {
      throw new RangeError('repeat count must not overflow maximum string size');
    }
    var rpt = '';
    for (;;) {
      if ((count & 1) == 1) {
        rpt += str;
      }
      count >>>= 1;
      if (count == 0) {
        break;
      }
      str += str;
    }
    return rpt;
  }
}

de la Chaîne.prototype.répéter est maintenant la norme ES6.

'abc'.repeat(3); //abcabcabc

expansion solution de P. Bailey :

String.prototype.repeat = function(num) {
    return new Array(isNaN(num)? 1 : ++num).join(this);
    }

de cette façon, vous devriez être à l'abri des types d'arguments inattendus:

var foo = 'bar';
alert(foo.repeat(3));              // Will work, "barbarbar"
alert(foo.repeat('3'));            // Same as above
alert(foo.repeat(true));           // Same as foo.repeat(1)

alert(foo.repeat(0));              // This and all the following return an empty
alert(foo.repeat(false));          // string while not causing an exception
alert(foo.repeat(null));
alert(foo.repeat(undefined));
alert(foo.repeat({}));             // Object
alert(foo.repeat(function () {})); // Function

EDIT: Crédits à jerone pour son élégance ++num idée!

Utiliser Array(N+1).join("string_to_repeat")

/**  
@desc: repeat string  
@param: n - times  
@param: d - delimiter  
*/

String.prototype.repeat = function (n, d) {
    return --n ? this + (d || '') + this.repeat(n, d) : '' + this
};

c'est comment répéter la chaîne de caractères plusieurs fois en utilisant le delimètre.

voici une amélioration de 5-7% sur la réponse de disfated.

déroule la boucle en s'arrêtant à count > 1 et exécute une concat supplémentaire result += pattnern après la boucle. Cela évitera les boucles finales pattern += pattern inutilisées précédemment sans avoir à utiliser un si-check coûteux. Le résultat final ressemblerait à ceci:

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;
};

et voici disfated's fiddle forked pour la version non roulée: http://jsfiddle.net/wsdfg/

function repeat(s, n) { var r=""; for (var a=0;a<n;a++) r+=s; return r;}

essais des différentes méthodes:

var repeatMethods = {
    control: function (n,s) {
        /* all of these lines are common to all methods */
        if (n==0) return '';
        if (n==1 || isNaN(n)) return s;
        return '';
    },
    divideAndConquer:   function (n, s) {
        if (n==0) return '';
        if (n==1 || isNaN(n)) return s;
        with(Math) { return arguments.callee(floor(n/2), s)+arguments.callee(ceil(n/2), s); }
    },
    linearRecurse: function (n,s) {
        if (n==0) return '';
        if (n==1 || isNaN(n)) return s;
        return s+arguments.callee(--n, s);
    },
    newArray: function (n, s) {
        if (n==0) return '';
        if (n==1 || isNaN(n)) return s;
        return (new Array(isNaN(n) ? 1 : ++n)).join(s);
    },
    fillAndJoin: function (n, s) {
        if (n==0) return '';
        if (n==1 || isNaN(n)) return s;
        var ret = [];
        for (var i=0; i<n; i++)
            ret.push(s);
        return ret.join('');
    },
    concat: function (n,s) {
        if (n==0) return '';
        if (n==1 || isNaN(n)) return s;
        var ret = '';
        for (var i=0; i<n; i++)
            ret+=s;
        return ret;
    },
    artistoex: function (n,s) {
        var result = '';
        while (n>0) {
            if (n&1) result+=s;
            n>>=1, s+=s;
        };
        return result;
    }
};
function testNum(len, dev) {
    with(Math) { return round(len+1+dev*(random()-0.5)); }
}
function testString(len, dev) {
    return (new Array(testNum(len, dev))).join(' ');
}
var testTime = 1000,
    tests = {
        biggie: { str: { len: 25, dev: 12 }, rep: {len: 200, dev: 50 } },
        smalls: { str: { len: 5, dev: 5}, rep: { len: 5, dev: 5 } }
    };
var testCount = 0;
var winnar = null;
var inflight = 0;
for (var methodName in repeatMethods) {
    var method = repeatMethods[methodName];
    for (var testName in tests) {
        testCount++;
        var test = tests[testName];
        var testId = methodName+':'+testName;
        var result = {
            id: testId,
            testParams: test
        }
        result.count=0;

        (function (result) {
            inflight++;
            setTimeout(function () {
                result.start = +new Date();
                while ((new Date() - result.start) < testTime) {
                    method(testNum(test.rep.len, test.rep.dev), testString(test.str.len, test.str.dev));
                    result.count++;
                }
                result.end = +new Date();
                result.rate = 1000*result.count/(result.end-result.start)
                console.log(result);
                if (winnar === null || winnar.rate < result.rate) winnar = result;
                inflight--;
                if (inflight==0) {
                    console.log('The winner: ');
                    console.log(winnar);
                }
            }, (100+testTime)*testCount);
        }(result));
    }
}

Voici la version sûre de JSLint

String.prototype.repeat = function (num) {
  var a = [];
  a.length = num << 0 + 1;
  return a.join(this);
};

pour tous les navigateurs

c'est aussi concis qu'il est:

function repeat(s, n) { return new Array(n+1).join(s); }

si vous vous souciez aussi de la performance, c'est une bien meilleure approche:

function repeat(s, n) { var a=[],i=0;for(;i<n;)a[i++]=s;return a.join(''); }

si vous voulez comparer les performances des deux options, consultez ce violon et ce violon pour les tests de référence. Lors de mes propres tests, le la deuxième option était environ 2 fois plus rapide dans Firefox et environ 4 fois plus rapide dans Chrome!

pour les navigateurs modernes uniquement:

dans les navigateurs modernes, vous pouvez maintenant aussi faire ceci:

function repeat(s,n) { return s.repeat(n) };

cette option est non seulement plus courte que les deux autres options, mais il est" 1519240920 encore plus rapide que la deuxième option.

malheureusement, il ne fonctionne dans aucune version de Internet explorer. Les nombres dans le tableau spécifient la première version de navigateur qui supporte pleinement la méthode:

function repeat(pattern, count) {
  for (var result = '';;) {
    if (count & 1) {
      result += pattern;
    }
    if (count >>= 1) {
      pattern += pattern;
    } else {
      return result;
    }
  }
}

vous pouvez le tester à JSFiddle . Comparé au hacky Array.join et le mien est, grosso modo, 10 (Chrome) à 100 (Safari) à 200 (Firefox) fois plus rapide (selon le navigateur).

juste une autre fonction de répétition:

function repeat(s, n) {
  var str = '';
  for (var i = 0; i < n; i++) {
    str += s;
  }
  return str;
}

ES2015 a été réalisé cette méthode repeat() !

http://www.ecma-international.org/ecma-262/6.0/#sec-string.prototype.repeat

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat

http://www.w3schools.com/jsref/jsref_repeat.asp

/** 
 * str: String
 * count: Number
 */
const str = `hello repeat!\n`, count = 3;

let resultString = str.repeat(count);

console.log(`resultString = \n${resultString}`);
/*
resultString = 
hello repeat!
hello repeat!
hello repeat!
*/

({ toString: () => 'abc', repeat: String.prototype.repeat }).repeat(2);
// 'abcabc' (repeat() is a generic method)

// Examples

'abc'.repeat(0);    // ''
'abc'.repeat(1);    // 'abc'
'abc'.repeat(2);    // 'abcabc'
'abc'.repeat(3.5);  // 'abcabcabc' (count will be converted to integer)
// 'abc'.repeat(1/0);  // RangeError
// 'abc'.repeat(-1);   // RangeError

peut être le plus petit récursif: -

String.prototype.repeat = function(n,s) {
s = s || ""
if(n>0) {
   s += this
   s = this.repeat(--n,s)
}
return s}

violon: http://jsfiddle.net/3Y9v2 /

function repeat(s, n){
    return ((new Array(n+1)).join(s));
}
alert(repeat('R', 10));

simple concursive concatenation

je voulais juste lui donner une fête, et j'ai fait ceci:

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

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

Je ne peux pas dire que je lui ai donné beaucoup de réflexion, et il montre probablement : -)

ce est sans doute meilleur

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

"foo".ditto( 128 );

et c'est un peu comme une réponse déjà postée - je le sais.

Mais pourquoi être récursive?

et comment A propos d'un petit comportement par défaut aussi?

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

"foo".ditto();

parce que , bien que la méthode non récursive va gérer arbitrairement de grandes répétitions sans frapper les limites de la pile d'appels, c'est beaucoup plus lent.

Pourquoi ai-je pris la peine d'ajouter d'autres méthodes qui ne sont pas à moitié aussi astucieuses que celles déjà publiées?

en partie pour mon propre plaisir, et en partie pour souligner de la manière la plus simple que je sais qu'il y a plusieurs façons de dépouiller un chat, et selon la situation, il est tout à fait possible que la méthode apparemment best n'est pas idéale.

une méthode relativement rapide et sophistiquée peut effectivement planter et brûler dans certaines circonstances, tandis qu'une méthode plus lente et plus simple peut faire le travail fait - éventuellement.

certaines méthodes peuvent être un peu plus que des exploits, et en tant que telles sujettes à être fixe hors de l'existence, et d'autres méthodes peuvent fonctionner magnifiquement dans toutes les conditions, mais sont construits de sorte que un tout simplement n'a aucune idée de la façon dont il fonctionne.

" et si je ne sais pas comment ça marche?!"

sérieusement?

JavaScript souffre d'une de ses plus grandes forces; il est très tolérant du mauvais comportement, et si flexible qu'il va se pencher en arrière pour rendre des résultats, quand il pourrait avoir été mieux pour tout le monde si il avait cassé!

"avec un grand pouvoir, vient une grande responsabilité" ; -)

mais plus sérieusement et surtout, bien que des questions générales comme celle-ci conduisent à l'étonnement sous la forme de intelligent réponses que si rien d'autre, élargir ses connaissances et des horizons, à la fin, la tâche à portée de main - le scénario pratique qui utilise la méthode résultant - peut exiger un peu moins, ou un peu plus intelligent que ce qui est suggéré.

ces " perfect " les algorithmes sont amusants et tout, mais "one size fits all" sera rarement, voire jamais mieux que sur mesure.

ce sermon vous a été apporté avec courtoisie d'un manque de sommeil et d'un intérêt passager. Aller de l'avant et de code!

tout d'abord, les questions de L'OP semblent être sur la concision - ce que je comprends à dire "simple et facile à lire", alors que la plupart des réponses semblent être sur l'efficacité - ce qui n'est évidemment pas la même chose et aussi je pense que si vous mettez en œuvre certains algorithmes très spécifiques de manipulation de grandes données, ne devrait pas vous inquiéter lorsque vous venez à mettre en œuvre des fonctions de base Javascript manipulation de données. La concision est beaucoup plus importante.

Deuxièmement, comme André Laszlo a noté, à la Chaîne.repeat fait partie D'ECMAScript 6 et est déjà disponible dans plusieurs implémentations populaires - donc l'implémentation la plus concise de String.repeat n'est pas de l'implémenter; -)

enfin, si vous avez besoin de prendre en charge des hôtes qui n'offrent pas L'implémentation D'ECMAScript 6, le polyfill de MDN mentionné par André Laszlo est tout sauf concis.

donc, sans plus attendre-voici mon concis polyfill:

String.prototype.repeat = String.prototype.repeat || function(n){
    return n<=1 ? this : this.concat(this.repeat(n-1));
}

Oui, c'est une récursivité. J'aime récurrences - ils sont simples et si c'est bien fait et facile à comprendre. En ce qui concerne l'efficacité, si le langage le supporte, ils peuvent être très efficaces s'ils sont écrits correctement.

D'après mes tests, cette méthode est environ 60% plus rapide que l'approche Array.join . Bien qu'elle ne vienne évidemment nulle part la mise en œuvre de disfated proche, il est beaucoup plus simple que les deux.

ma configuration de test est node v0.10, en utilisant "Mode Strict "(je pense qu'il permet une sorte de TCO ), appelant repeat(1000) sur une chaîne de 10 caractères un million de fois.

utilisez Lodash pour les fonctionnalités utilitaires Javascript, comme répéter des chaînes.

Lodash offre de belles performances et une compatibilité ECMAScript.

je le recommande fortement pour le développement de L'interface utilisateur et il fonctionne bien Côté Serveur, aussi.

Voici comment répéter la chaîne "yo" 2 fois en utilisant Lodash:

> _.repeat('yo', 2)
"yoyo"

solution Récursive à l'aide de diviser pour régner:

function repeat(n, s) {
    if (n==0) return '';
    if (n==1 || isNaN(n)) return s;
    with(Math) { return repeat(floor(n/2), s)+repeat(ceil(n/2), s); }
}

je suis venu ici au hasard et n'ai jamais eu une raison de répéter un char en javascript avant.

j'ai été impressionné par la façon de faire d'artistoex et les résultats de disfated. J'ai remarqué que la dernière chaîne concat n'était pas nécessaire, comme Dennis l'a également souligné.

j'ai remarqué un peu plus de choses en jouant avec l'échantillonnage disfated mettre ensemble.

les résultats ont varié un bon nombre souvent en faveur de la dernière exécution et des algorithmes similaires souvent jockey pour la position. Une des choses que j'ai changées était au lieu d'utiliser le compte généré par JSLitmus comme graine pour les appels; comme le compte a été généré différent pour les différentes méthodes, j'ai mis un index. Cela rendait la chose beaucoup plus fiable. J'ai ensuite veillé à ce que des cordes de différentes tailles soient passées aux fonctions. Cela a empêché certaines des variations que j'ai vu, où certains algorithmes ont fait mieux à la charrue simple ou des cordes plus petites. Cependant, le top 3 des méthodes tout a fait bien quelle que soit la taille de la chaîne.

fourked test set

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();

J'ai alors Inclus Le fix de Dennis et j'ai décidé de voir si je pouvais trouver un moyen de sortir un peu plus.

comme javascript ne peut pas vraiment optimiser les choses, la meilleure façon d'améliorer les performances est d'éviter les choses manuellement. Si j'ai pris les 4 premiers résultats triviaux hors de la boucle, je pourrait éviter 2-4 magasins de chaîne de caractères et écrire le magasin final directement au résultat.

// 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;
}

cela s'est traduit par une amélioration de 1 à 2% en moyenne par rapport au correctif de Dennis. Cependant, des passages différents et des navigateurs différents montreraient une variance assez juste que ce code supplémentaire ne vaut probablement pas l'effort par rapport aux 2 algorithmes précédents.

Un tableau

Edit: je l'ai fait principalement sous chrome. Firefox et IE will favorise souvent Dennis de quelques pour cent.

méthode Simple:

String.prototype.repeat = function(num) {
    num = parseInt(num);
    if (num < 0) return '';
    return new Array(num + 1).join(this);
}

les Gens compliquer ce ridicule de mesure ou de déchets de performance. Les tableaux? La récursivité? Vous vous moquez de moi.

function repeat (string, times) {
  var result = ''
  while (times-- > 0) result += string
  return result
}

Edit. j'ai fait quelques tests simples pour comparer avec la version bitwise Postée par artistoex / disfated et un tas d'autres personnes. Ce dernier n'était que légèrement plus rapide, mais des ordres de grandeur plus économes en mémoire. Pour 1000000 répétitions du mot 'blah', le processus de noeud est monté à 46 mégaoctets avec l'algorithme de concaténation simple (ci-dessus), mais seulement 5,5 mégaoctets avec l'algorithme logarithmique. Ce dernier point est certainement la voie à suivre.

function repeat (string, times) {
  var result = ''
  while (times > 0) {
    if (times & 1) result += string
    times >>= 1
    string += string
  }
  return result
}

si vous pensez que toutes les définitions de prototypes, les créations de tableaux et les opérations de jointure sont exagérées, utilisez simplement un code en ligne là où vous en avez besoin. String s répétant N fois:

for (var i = 0, result = ''; i < N; i++) result += S;

chaînes Concaténantes basées sur un nombre.

function concatStr(str, num) {
   var arr = [];

   //Construct an array
   for (var i = 0; i < num; i++)
      arr[i] = str;

   //Join all elements
   str = arr.join('');

   return str;
}

console.log(concatStr("abc", 3));

Espère que ça aide!