web-dev-qa-db-de.com

Erstellen Sie einen String mit variabler Länge, der mit einem wiederholten Zeichen gefüllt ist

Meine Frage wurde also von jemand anderem in seiner Java-Form hier gestellt: Java - Erstellen Sie eine neue String-Instanz mit der angegebenen Länge und mit einem bestimmten Zeichen. Beste Lösung?

. . . aber ich suche sein JavaScript-Äquivalent.

Grundsätzlich möchte ich Textfelder dynamisch mit "#" - Zeichen füllen, basierend auf dem Attribut "maxlength" jedes Felds. Wenn also eine Eingabe maxlength="3" hat, wird das Feld mit "###" gefüllt.

Idealerweise gäbe es so etwas wie Java StringUtils.repeat("#", 10);, aber bis jetzt ist die beste Option, die ich mir vorstellen kann, die "#" - Zeichen nacheinander zu durchlaufen und anzufügen, bis die maximale Länge erreicht ist. Ich kann das Gefühl nicht abschütteln, dass es einen effizienteren Weg gibt, als dies zu tun.

Irgendwelche Ideen?

Zu Ihrer Information - Ich kann nicht einfach einen Standardwert in der Eingabe festlegen, da die "#" - Zeichen den Fokus löschen müssen, und wenn der Benutzer keinen Wert eingegeben hat, muss bei Unschärfe "nachgefüllt" werden. Es ist der "Nachfüllschritt", mit dem ich mich beschäftige

129
talemyn

Der beste Weg, dies zu tun (was ich gesehen habe) ist 

var str = new Array(len + 1).join( character );

Dadurch wird ein Array mit der angegebenen Länge erstellt und anschließend mit der angegebenen Zeichenfolge zur Wiederholung verbunden. Die Funktion .join() berücksichtigt die Arraylänge unabhängig davon, ob den Elementen Werte zugewiesen wurden, und undefinierte Werte werden als leere Zeichenfolgen dargestellt.

Sie müssen der gewünschten Länge 1 hinzufügen, da die Trennzeichenfolge zwischen den Array-Elementen geht.

261
Pointy

Probieren Sie es aus: P

s = '#'.repeat(10)

document.body.innerHTML = s

106
user4227915

Obwohl der hier erwähnte Ansatz von Array.join knapp ist, ist er zwar etwa zehnmal langsamer als eine auf String-Verkettung basierende Implementierung. Es ist besonders schlecht bei großen Saiten. Die vollständigen Leistungsdetails finden Sie unten.

Bei Firefox, Chrome, Node.js MacOS, Node.js Ubuntu und Safari war die schnellste Implementierung, die ich getestet habe:

function repeatChar(count, ch) {
    if (count == 0) {
        return "";
    }
    var count2 = count / 2;
    var result = ch;

    // double the input until it is long enough.
    while (result.length <= count2) {
        result += result;
    }
    // use substring to hit the precise length target without
    // using extra memory
    return result + result.substring(0, count - result.length);
};

Dies ist wortreich, wenn Sie also eine knappe Implementierung wünschen, können Sie sich für den naiven Ansatz entscheiden. Es ist immer noch zwischen 2X und 10X besser als der Array.join-Ansatz und auch schneller als die Verdopplungsimplementierung für kleine Eingaben. Code:

// naive approach: simply add the letters one by one
function repeatChar(count, ch) {
    var txt = "";
    for (var i = 0; i < count; i++) {
        txt += ch;
    }
    return txt;
}

Weitere Informationen:

28
Zero Trick Pony

Ich würde eine konstante Zeichenfolge erstellen und dann Teilzeichenfolge darauf aufrufen.

So etwas wie 

var hashStore = '########################################';

var Fiveup = hashStore.substring(0,5);

var Tenup = hashStore.substring(0,10);

Auch etwas schneller.

http://jsperf.com/const-vs-join

20
Hogan

ES2015 ist der einfachste Weg, so etwas zu tun

'X'.repeat(data.length)

X ist eine beliebige Zeichenfolge, data.length ist die gewünschte Länge.

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

11
Weeks

Version, die in allen Browsern funktioniert

Diese Funktion macht, was Sie wollen, und ist viel schneller 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('');
}

Du verwendest es so:

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

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

Version nur für moderne Browser

In modernen Browsern können Sie jetzt auch Folgendes tun:

var repeatedCharacter = "a".repeat(10) };

Diese Option ist noch schneller. Leider funktioniert es in keiner Version von Internet Explorer. 

Die Zahlen in der Tabelle geben die erste Browserversion an, die die Methode vollständig unterstützt:

 enter image description here

3
John Slegers
For Evergreen browsers, this will build a staircase based on an incoming character and the number of stairs to build.
function StairCase(character, input) {
    let i = 0;
    while (i < input) {
        const spaces = " ".repeat(input - (i+1));
        const hashes = character.repeat(i + 1);
        console.log(spaces + hashes);
        i++;
    }
}

//Implement
//Refresh the console
console.clear();
StairCase("#",6);   

Sie können auch eine Mehrfachfüllung für Wiederholen für ältere Browser hinzufügen

    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;
      }
    } 
3
Terry Slack

Basierend auf Antworten von Hogan und Zero Trick Pony. Ich denke, das sollte sowohl schnell als auch flexibel genug sein, um die meisten Anwendungsfälle gut handhaben zu können: 

var hash = '####################################################################'

function build_string(length) {  
    if (length == 0) {  
        return ''  
    } else if (hash.length <= length) {  
        return hash.substring(0, length)  
    } else {  
        var result = hash  
        const half_length = length / 2  
        while (result.length <= half_length) {  
            result += result  
        }  
        return result + result.substring(0, length - result.length)  
    }  
}  
2
Leandro

Eine gute ES6-Option wäre padStart eine leere Zeichenfolge. So was:

var str = ''.padStart(10, "#");

Hinweis: Dies funktioniert nicht in IE (ohne Polyfill).

1
Mendy

Sie können die erste Zeile der Funktion als Einzeiler verwenden, wenn Sie möchten:

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