Utwórz ciąg o zmiennej długości, wypełniony powtarzającym się znakiem

Tak więc moje pytanie zostało zadane przez kogoś innego w jego formie Java : Java - Utwórz nową instancję String o określonej długości i wypełnioną określonym znakiem. Najlepsze rozwiązanie?

. . . ale szukam jego odpowiednika w JavaScript.

Zasadniczo chcę dynamicznie wypełniać pola tekstowe znakami „#” na podstawie atrybutu „maxlength” każdego pola. Tak więc, jeśli wejście ma maxlength="3", to pole zostanie wypełnione „###”.

Idealnie byłoby coś takiego jak Java StringUtils.repeat("#", 10);, ale jak dotąd najlepszą opcją, jaką przychodzi mi do głowy, jest zapętlanie i dodawanie znaków „#”, jeden po drugim, aż do osiągnięcia maksymalnej długości. Nie mogę pozbyć się wrażenia, że ​​jest na to skuteczniejszy sposób niż to.

Jakieś pomysły?

Do Twojej wiadomości - nie mogę po prostu ustawić wartości domyślnej w danych wejściowych, ponieważ znaki „#” muszą zostać wyczyszczone przy fokusie, a jeśli użytkownik nie wprowadził wartości, będą musiały zostać „uzupełnione” przy rozmyciu. Martwię się o krok „uzupełnienia”

Najlepszym sposobem na to (jaki widziałem) jest

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

To tworzy tablicę o określonej długości, a następnie łączy ją z podanym ciągiem do powtórzenia. .join()Funkcja wyróżnieniem długości tablicy, niezależnie od tego, czy elementy mieć przypisane wartości, zaś wartości nieokreślone są prezentowane jako puste.

Musisz dodać 1 do żądanej długości, ponieważ ciąg separatora znajduje się między elementami tablicy.

Spróbuj: P

s = '#'.repeat(10)

document.body.innerHTML = s

Niestety, chociaż wspomniane tutaj podejście Array.join jest zwięzłe, jest około 10 razy wolniejsze niż implementacja oparta na konkatenacji ciągów. Szczególnie słabo radzi sobie na dużych strunach. Zobacz poniżej pełne szczegóły dotyczące wydajności.

W przeglądarkach Firefox, Chrome, Node.js MacOS, Node.js Ubuntu i Safari najszybsza implementacja, którą przetestowałem, to:

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

To jest rozwlekłe, więc jeśli chcesz zwięzłej implementacji, możesz wybrać naiwne podejście; nadal działa od 2X do 10X lepiej niż podejście Array.join, a także jest szybszy niż implementacja podwajania dla małych danych wejściowych. Kod:

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

Dalsza informacja:

• Uruchom test szybkości we własnej przeglądarce
• Pełny kod źródłowy testu szybkości
• Wyniki testów szybkości

Utworzyłbym ciąg stały, a następnie wywołałbym na nim podciąg.

Coś jak

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

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

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

Nieco szybciej też.

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

ES2015 najłatwiej jest zrobić coś takiego

'X'.repeat(data.length)

Xbędący dowolnym ciągiem, data.lengthbędący pożądaną długością.

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

Świetną opcją w ES6 byłby padStartpusty łańcuch. Lubię to:

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

Uwaga: to nie zadziała w IE (bez polyfill).

Wersja działająca we wszystkich przeglądarkach

Ta funkcja robi to, co chcesz i działa znacznie szybciej niż opcja sugerowana w zaakceptowanej odpowiedzi:

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

Używasz tego w ten sposób:

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

Aby porównać wydajność tej funkcji z opcją zaproponowaną w zaakceptowanej odpowiedzi, zobacz testy porównawcze tego Fiddle'a i tego Fiddle'a .

Wersja tylko dla nowoczesnych przeglądarek

W nowoczesnych przeglądarkach możesz teraz również to zrobić:

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

Ta opcja jest jeszcze szybsza. Jednak niestety nie działa w żadnej wersji przeglądarki Internet Explorer.

Liczby w tabeli określają pierwszą wersję przeglądarki, która w pełni obsługuje tę metodę:

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

W starszych przeglądarkach możesz także dodać wypełnienie tekstowe dla opcji Powtórz

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

Na podstawie odpowiedzi Hogana i Zero Trick Pony. Myślę, że powinno to być zarówno szybkie, jak i wystarczająco elastyczne, aby dobrze obsłużyć większość przypadków użycia:

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

Możesz użyć pierwszej linii funkcji jako linijki, jeśli chcesz:

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