Repetir Carácter N Veces

En una nueva armonía ES6, tendrá una forma nativa de hacer esto con repeat. También ES6 en este momento solo experimental, esta característica es ya disponible en Edge, FF, Chrome y Safari

"abc".repeat(3) // "abcabcabc"

Y seguramente si la función de repetición no está disponible, puede usar old-good Array(n + 1).join("abc")

Conveniente si te repites mucho:

String.prototype.repeat = String.prototype.repeat || function(n){
  n= n || 1;
  return Array(n+1).join(this);
}

alert(  'Are we there yet?\nNo.\n'.repeat(10)  )

La manera más rendimiento-wice es https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat

La versión corta está abajo.

  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;
    }
    return result + pattern;
  };
  var a = "a";
  console.debug(a.repeat(10));

Polyfill de Mozilla:

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;
    }
    // Could we try:
    // return Array(count + 1).join(this);
    return rpt;
  }
}

Una alternativa es:

for(var word = ''; word.length < 10; word += 'a'){}

Si necesita repetir varios caracteres, multiplique su condicional:

for(var word = ''; word.length < 10 * 3; word += 'foo'){}

NOTA: No tienes que sobrepasar en 1 como con word = Array(11).join('a')

Si no se opone a incluir una biblioteca en su proyecto, lodash tiene una función de repetición.

_.repeat('*', 3);
// → '***

Https://lodash.com/docs#repeat

Para todos los navegadores

La siguiente función funcionará mucho más rápido que la opción sugerida en la respuesta aceptada:

var repeat = function(str, count) {
    var array = [];
    for(var i = 0; i < count;)
        array[i++] = str;
    return array.join('');
}

Lo usarías así:

var repeatedString = repeat("a", 10);

, Para comparar el desempeño de esta función con la de la opción propuesta en respuesta, ver este Violín y este Violín para los benchmarks.

Solo para navegadores modernos

En los navegadores modernos, ahora puede hacer esto usando String.prototype.repeat método:

var repeatedString = "a".repeat(10);

Lea más sobre este método en MDN.

Esta opción es aún más rápida. Desafortunadamente, no funciona en ninguna versión de Internet Explorer. Los números de la tabla especifican la primera versión del navegador que soporta completamente el método:

Array(10).fill('a').join('')

Aunque la respuesta más votada es un poco más compacta, con este enfoque no tiene que agregar un elemento de matriz adicional.

En ES2015 / ES6 puedes usar "*".repeat(n)

Así que simplemente agregue esto a sus proyectos, y estará listo.

  String.prototype.repeat = String.prototype.repeat || 
    function(n) {
      if (n < 0) throw new RangeError("invalid count value");
      if (n == 0) return "";
      return new Array(n + 1).join(this.toString()) 
    };

/**  
 * Repeat a string `n`-times (recursive)
 * @param {String} s - The string you want to repeat.
 * @param {Number} n - The times to repeat the string.
 * @param {String} d - A delimiter between each string.
 */

var repeat = function (s, n, d) {
    return --n ? s + (d || "") + repeat(s, n, d) : "" + s;
};

var foo = "foo";
console.log(
    "%s\n%s\n%s\n%s",

    repeat(foo),        // "foo"
    repeat(foo, 2),     // "foofoo"
    repeat(foo, "2"),   // "foofoo"
    repeat(foo, 2, "-") // "foo-foo"
);

Otra forma interesante de rápidamente repetir n carácter es utilizar la idea del algoritmo de exponenciación rápida:

var repeatString = function(string, n) {
    var result = '', i;

    for (i = 1; i <= n; i *= 2) {
        if ((n & i) === i) {
            result += string;
        }
        string = string + string;
    }

    return result;
};

Para repetir un valor en mis proyectos uso repetir

Por ejemplo:

var n = 6;
for (i = 0; i < n; i++) {
    console.log("#".repeat(i+1))
}

Pero tenga cuidado porque este método se ha añadido a la especificación ECMAScript 6.

Esto es lo que uso:

function repeat(str, num) {
        var holder = [];
        for(var i=0; i<num; i++) {
            holder.push(str);
        }
        return holder.join('');
    }

function repeatString(n, string) {
  var repeat = [];
  repeat.length = n + 1;
  return repeat.join(string);
}

repeatString(3,'x'); // => xxx
repeatString(10,''); // => ""

Voy a ampliar la respuesta de@bonbon. Su método es una manera fácil de" anexar N caracteres a una cadena existente", en caso de que alguien necesite hacerlo. Por ejemplo, dado que "un google" es un 1 seguido de 100 ceros.

for(var google = '1'; google.length < 1 + 100; google += '0'){}
document.getElementById('el').innerText = google;

<div>This is "a google":</div>
<div id="el"></div>

NOTA: Tiene que agregar la longitud de la cadena original al condicional.

Lodash ofrece una funcionalidad similar a la función Javascript repeat() que no está disponible en todos los navegadores. Se llama _.repeat y disponible desde la versión 3.0.0:

_.repeat('a', 10);

var stringRepeat = function(string, val) {
  var newString = [];
    for(var i = 0; i < val; i++) {
      newString.push(string);
  }
  return newString.join('');
}

var repeatedString = stringRepeat("a", 1);

También se puede usar como un solo revestimiento:

function repeat(str, len) {
    while (str.length < len) str += str.substr(0, len-str.length);
    return str;
}

En CoffeeScript:

( 'a' for dot in [0..10]).join('')

String.prototype.repeat = function (n) { n = Math.abs(n) || 1; return Array(n + 1).join(this || ''); };

// console.log("0".repeat(3) , "0".repeat(-3))
// return: "000" "000"

Aquí hay una versión ES6

const repeat = (a,n) => Array(n).join(a+"|$|").split("|$|");
repeat("A",20).forEach((a,b) => console.log(a,b+1))