Wiederholen Sie das Zeichen N Mal

In Perl kann ich ein Zeichen mit der folgenden Syntax mehrmals wiederholen:

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

Gibt es eine einfache Möglichkeit, dies in Javascript zu erreichen? Ich kann natürlich eine Funktion verwenden, aber ich habe mich gefragt, ob es einen eingebauten Ansatz oder eine andere clevere Technik gibt.

Heutzutage ist die repeatString-Methode fast überall implementiert . (Es befindet sich nicht in Internet Explorer .) Wenn Sie also keine älteren Browser unterstützen müssen, können Sie einfach schreiben:

"a".repeat(10)

Vorher repeathaben wir diesen Hack benutzt:

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

(Beachten Sie, dass ein Array mit der Länge 11 nur 10 "a" ergibt , da Array.joindas Argument zwischen den Array-Elementen steht.)

Simon weist auch darauf hin, dass es laut jsperf in Safari und Chrome (aber nicht in Firefox) schneller zu sein scheint, ein Zeichen mehrmals zu wiederholen, indem einfach eine for-Schleife angehängt wird (obwohl etwas weniger präzise).

In einer neuen ES6-Harmonie haben Sie eine native Möglichkeit, dies mit Wiederholung zu tun . Auch ES6 derzeit nur experimentell, diese Funktion ist bereits in Edge, FF, Chrome und Safari verfügbar

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

Und wenn die Wiederholungsfunktion nicht verfügbar ist, können Sie sicherlich old-good verwenden Array(n + 1).join("abc")

Praktisch, wenn Sie sich oft wiederholen:

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

Der leistungsfähigste Weg ist https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat

Kurzversion ist unten.

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

Eine Alternative ist:

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

Wenn Sie mehrere Zeichen wiederholen müssen, multiplizieren Sie Ihre Bedingung:

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

HINWEIS: Sie müssen nicht wie bei um 1 überschießenword = Array(11).join('a')

Wenn Sie nicht dagegen sind, eine Bibliothek in Ihr Projekt aufzunehmen, verfügt lodash über eine Wiederholungsfunktion.

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

https://lodash.com/docs#repeat

Für alle Browser

Die folgende Funktion wird viel schneller ausgeführt als die in der akzeptierten Antwort vorgeschlagene Option:

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

Sie würden es so verwenden:

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

Um die Leistung dieser Funktion mit der der in der akzeptierten Antwort vorgeschlagenen Option zu vergleichen, finden Sie Benchmarks in dieser Geige und dieser Geige .

Nur für moderne Browser

In modernen Browsern können Sie dies jetzt mit folgender String.prototype.repeatMethode tun :

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

Lesen Sie mehr über diese Methode auf MDN .

Diese Option ist noch schneller. Leider funktioniert es in keiner Version des Internet Explorers. Die Zahlen in der Tabelle geben die erste Browserversion an, die die Methode vollständig unterstützt:

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

Obwohl die am häufigsten gewählte Antwort etwas kompakter ist, müssen Sie bei diesem Ansatz kein zusätzliches Array-Element hinzufügen.

/**  
 * 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 können Sie verwenden "*".repeat(n)

Fügen Sie dies einfach zu Ihren Projekten hinzu, und schon kann es losgehen.

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

Eine andere interessante Möglichkeit, n Zeichen schnell zu wiederholen, besteht darin, die Idee eines schnellen Exponentiationsalgorithmus zu verwenden:

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

Um einen Wert in meinen Projekten zu wiederholen, verwende ich repeat

Zum Beispiel:

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

Seien Sie jedoch vorsichtig, da diese Methode zur ECMAScript 6-Spezifikation hinzugefügt wurde.

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

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

Folgendes benutze ich:

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

Ich werde die Antwort von @ bonbon erweitern . Seine Methode ist eine einfache Möglichkeit, "N Zeichen an eine vorhandene Zeichenfolge anzuhängen", nur für den Fall, dass jemand dies tun muss. Zum Beispiel, da "ein Google" eine 1 ist, gefolgt von 100 Nullen .

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>

HINWEIS: Sie müssen der Bedingung die Länge der ursprünglichen Zeichenfolge hinzufügen.

Lodash bietet eine ähnliche Funktionalität wie die Funktion Javascript repeat () , die nicht in allen Browsern verfügbar ist. Es heißt _.repeat und ist seit Version 3.0.0 verfügbar:

_.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);

Kann auch als Einzeiler verwendet werden:

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

Auf diese Weise können Sie eine Funktion aufrufen und das Ergebnis mithilfe von Array () und join () abrufen.

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"

Hier ist eine ES6-Version

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