Ripeti il ​​personaggio N volte

In Perl posso ripetere più volte un personaggio usando la sintassi:

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

C'è un modo semplice per ottenere questo risultato in Javascript? Ovviamente posso usare una funzione, ma mi chiedevo se ci fosse un approccio integrato o qualche altra tecnica intelligente.

In questi giorni, il repeatmetodo stringa è implementato quasi ovunque. (Non è in Internet Explorer .) Quindi, a meno che non sia necessario supportare browser meno recenti, è possibile semplicemente scrivere:

"a".repeat(10)

Prima repeat, abbiamo usato questo trucco:

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

(Nota che un array di lunghezza 11 ti dà solo 10 "a" s, poiché Array.joinmette l'argomento tra gli elementi dell'array.)

Simon sottolinea anche che secondo questo jsperf , sembra che sia più veloce in Safari e Chrome (ma non Firefox) ripetere un personaggio più volte semplicemente aggiungendo un ciclo for (anche se un po 'meno conciso).

In una nuova armonia ES6, avrai un modo nativo per farlo ripetendo . Anche ES6 in questo momento solo sperimentale, questa funzione è già disponibile in Edge, FF, Chrome e Safari

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

E sicuramente se la funzione di ripetizione non è disponibile, puoi usare old-good Array(n + 1).join("abc")

Conveniente se ti ripeti molto:

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

Il modo più performante è https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat

La versione breve è sotto.

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

Un'alternativa è:

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

Se devi ripetere più caratteri, moltiplica il tuo condizionale:

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

NOTA: non è necessario eseguire il superamento di 1 come perword = Array(11).join('a')

Se non sei contrario a includere una biblioteca nel tuo progetto, lodash ha una funzione di ripetizione.

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

https://lodash.com/docs#repeat

Per tutti i browser

La seguente funzione sarà molto più veloce dell'opzione suggerita nella risposta accettata:

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

Lo useresti così:

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

Per confrontare le prestazioni di questa funzione con quelle dell'opzione proposta nella risposta accettata, vedere questo Fiddle e questo Fiddle per i benchmark.

Solo per browser moderni

Nei browser moderni, ora puoi farlo utilizzando il String.prototype.repeatmetodo:

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

Ulteriori informazioni su questo metodo su MDN .

Questa opzione è ancora più veloce. Sfortunatamente, non funziona in nessuna versione di Internet Explorer. I numeri nella tabella specificano la prima versione del browser che supporta completamente il metodo:

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

Sebbene la risposta più votata sia un po 'più compatta, con questo approccio non è necessario aggiungere un ulteriore elemento dell'array.

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

In ES2015 / ES6 è possibile utilizzare "*".repeat(n)

Quindi aggiungi questo ai tuoi progetti e sei pronto per partire.

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

Un altro modo interessante per ripetere rapidamente n carattere è usare l'idea dall'algoritmo di esponenziazione rapida:

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

Per ripetere un valore nei miei progetti, utilizzo repeat

Per esempio:

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

ma fai attenzione perché questo metodo è stato aggiunto alla specifica ECMAScript 6.

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

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

Ecco cosa uso:

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

Espanderò la risposta di @ bonbon . Il suo metodo è un modo semplice per "aggiungere N caratteri a una stringa esistente", nel caso in cui qualcuno debba farlo. Ad esempio, poiché "un google" è un 1 seguito da 100 zeri .

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: è necessario aggiungere la lunghezza della stringa originale al condizionale.

Lodash offre una funzionalità simile alla funzione Javascript repeat () che non è disponibile in tutti i browser. Si chiama _.repeat ed è disponibile dalla versione 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);

Può essere usato anche come un liner:

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

In CoffeeScript:

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

questo è il modo in cui è possibile chiamare una funzione e ottenere il risultato con l'aiuto di Array () e 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"

Ecco una versione ES6

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