Erstellen Sie eine Zeichenfolge mit variabler Länge, die mit einem wiederholten Zeichen gefüllt ist

Daher wurde meine Frage hier von einer anderen Person in Java-Form gestellt: Java - Erstellen Sie eine neue String-Instanz mit der angegebenen Länge und dem angegebenen Zeichen. Beste Lösung?

. . . aber ich suche nach seinem JavaScript-Äquivalent.

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

Im Idealfall gibt es so etwas wie Java StringUtils.repeat("#", 10);, aber bisher ist die beste Option, die ich mir vorstellen kann, das Durchlaufen und Anhängen der "#" - Zeichen nacheinander, bis die maximale Länge erreicht ist. Ich kann das Gefühl nicht loswerden, dass es einen effizienteren Weg gibt, dies zu tun.

Irgendwelche Ideen?

Zu Ihrer Information - Ich kann nicht einfach einen Standardwert in der Eingabe festlegen, da die "#" Zeichen im Fokus gelöscht werden müssen und, wenn der Benutzer keinen Wert eingegeben hat, bei Unschärfe "nachgefüllt" werden müssen. Es ist der "Nachfüll" -Schritt, mit dem ich mich befasse

Der beste Weg dies zu tun (den 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 verknüpft, um es zu wiederholen. Die .join()Funktion berücksichtigt die Array-Länge, unabhängig davon, ob den Elementen Werte zugewiesen wurden, und undefinierte Werte werden als leere Zeichenfolgen gerendert.

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

Probieren Sie es aus: P.

s = '#'.repeat(10)

document.body.innerHTML = s

Obwohl der hier erwähnte Array.join-Ansatz knapp ist, ist er leider etwa 10-mal langsamer als eine auf String-Verkettung basierende Implementierung. Es funktioniert besonders schlecht bei großen Saiten. Siehe unten für vollständige Leistungsdetails.

Unter 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 ausführlich. Wenn Sie also eine knappe Implementierung wünschen, können Sie sich für den naiven Ansatz entscheiden. Es bietet immer noch eine 2- bis 10-fache Leistung zwischen dem Array.join-Ansatz und ist außerdem 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:

• Führen Sie den Geschwindigkeitstest in Ihrem eigenen Browser durch
• Vollständiger Quellcode des Geschwindigkeitstests
• Geschwindigkeitstestergebnisse

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

Etwas wie

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

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

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

Ein bisschen schneller auch.

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

ES2015 ist der einfachste Weg, so etwas zu tun

'X'.repeat(data.length)

Xeine beliebige Zeichenfolge sein, data.lengthdie gewünschte Länge.

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

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

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

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

Version, die in allen Browsern funktioniert

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

Sie verwenden 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 Benchmarks in dieser Geige und dieser Geige .

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 des Internet Explorers.

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

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 Polyfill für Repeat 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;
      }
    } 

Basierend auf Antworten von Hogan und Zero Trick Pony. Ich denke, dies sollte schnell und flexibel genug sein, um die meisten Anwendungsfälle gut zu bewältigen:

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

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