Repetir personaje N veces

En Perl puedo repetir un personaje varias veces usando la sintaxis:

$a = "a" x 10; // results in "aaaaaaaaaa"

¿Hay una manera simple de lograr esto en Javascript? Obviamente puedo usar una función, pero me preguntaba si había algún enfoque integrado, o alguna otra técnica inteligente.

En estos días, el repeatmétodo de cadena se implementa en casi todas partes. (No está en Internet Explorer ). Entonces, a menos que necesite admitir navegadores más antiguos, simplemente puede escribir:

"a".repeat(10)

Antes repeat, usamos este truco:

Array(11).join("a") // create string with 10 a's: "aaaaaaaaaa"

(Tenga en cuenta que una matriz de longitud 11 solo obtiene 10 "a" s, ya que Array.joincoloca el argumento entre los elementos de la matriz).

Simon también señala que de acuerdo con este jsperf , parece que es más rápido en Safari y Chrome (pero no en Firefox) repetir un personaje varias veces simplemente agregando usando un bucle for (aunque un poco menos conciso).

En una nueva armonía ES6, tendrá una forma nativa de hacer esto con la repetición . También ES6 ahora solo experimental, esta característica ya está 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 forma más inteligente de rendimiento 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 tiene que sobrepasar en 1 como conword = 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 rendimiento de esta función con el de la opción propuesta en la respuesta aceptada, vea este violín y este violín para obtener puntos de referencia.

Solo para navegadores modernos

En los navegadores modernos, ahora puede hacer esto usando el String.prototype.repeatmé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 en la tabla especifican la primera versión del navegador que soporta totalmente este 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.

/**  
 * 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"
);

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

Así que solo agregue esto a sus proyectos, y estará listo para comenzar.

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

Otra forma interesante de repetir rápidamente n caracteres es usar 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 agregado a la especificación ECMAScript 6.

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

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

Esto es lo que uso:

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

Voy a ampliar la respuesta de @bonbon . Su método es una manera fácil de "agregar N caracteres a una cadena existente", en caso de que alguien necesite hacer eso. 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: Debe agregar la longitud de la cadena original al condicional.

Lodash ofrece una funcionalidad similar a la función de repetición () de Javascript que no está disponible en todos los navegadores. Se llama _.repeat y está 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 una sola línea:

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

así es como puede llamar a una función y obtener el resultado con la ayuda de Array () y join ()

function repeatStringNumTimes(str, num) {
  // repeat after me
  return num > 0 ? Array(num+1).join(str) : "";
}

console.log(repeatStringNumTimes("a",10))

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