Crie uma sequência de comprimento variável, preenchida com um caractere repetido

Então, minha pergunta foi feita por outra pessoa em seu formulário Java aqui: Java - Crie uma nova instância String com comprimento especificado e preenchido com caracteres específicos. Melhor solução?

. . . mas estou procurando pelo seu equivalente em JavaScript.

Basicamente, pretendo preencher dinamicamente os campos de texto com caracteres "#", com base no atributo "comprimento máximo" de cada campo. Portanto, se uma entrada tiver maxlength="3", o campo será preenchido com "###".

Idealmente, haveria algo como o Java StringUtils.repeat("#", 10);, mas, até agora, a melhor opção em que posso pensar é percorrer e acrescentar os caracteres "#", um de cada vez, até que o comprimento máximo seja atingido. Não posso deixar de pensar que existe uma maneira mais eficiente de fazer isso do que isso.

Alguma ideia?

FYI - Não posso simplesmente definir um valor padrão na entrada, porque os caracteres "#" precisam ser claros no foco e, se o usuário não inseriu um valor, será necessário "reabastecer" no desfoque. É o passo de "reabastecimento" que me preocupa

A melhor maneira de fazer isso (que eu já vi) é

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

Isso cria uma matriz com o comprimento especificado e, em seguida, une-a à sequência especificada para repetir. A .join()função respeita o comprimento da matriz, independentemente de os elementos terem valores atribuídos e valores indefinidos serem renderizados como cadeias vazias.

Você precisa adicionar 1 ao comprimento desejado porque a cadeia separadora fica entre os elementos da matriz.

Faça uma tentativa: P

s = '#'.repeat(10)

document.body.innerHTML = s

Infelizmente, embora a abordagem Array.join mencionada aqui seja concisa, é cerca de 10 vezes mais lenta que uma implementação baseada em concatenação de cadeias. Ele executa especialmente mal em grandes seqüências de caracteres. Veja abaixo os detalhes completos de desempenho.

No Firefox, Chrome, Node.js.MOSOS, Node.js. Ubuntu e Safari, a implementação mais rápida que testei foi:

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

Isso é detalhado, portanto, se você quiser uma implementação concisa, poderá usar a abordagem ingênua; ele ainda executa entre 2 e 10 vezes melhor que a abordagem Array.join e também é mais rápido que a implementação duplicada para pequenas entradas. Código:

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

Outras informações:

• Execute o teste de velocidade no seu próprio navegador
• Código fonte completo do teste de velocidade
• Resultados do teste de velocidade

Eu criaria uma string constante e depois chamaria a substring.

Algo como

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

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

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

Um pouco mais rápido também.

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

ES2015, a maneira mais fácil é fazer algo como

'X'.repeat(data.length)

Xsendo qualquer string, data.lengthsendo o comprimento desejado.

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

Uma ótima opção do ES6 seria padStartuma string vazia. Como isso:

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

Nota: isso não funcionará no IE (sem um polyfill).

Versão que funciona em todos os navegadores

Esta função faz o que você deseja e executa muito mais rapidamente do que a opção sugerida na resposta aceita:

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

Você usa assim:

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

Para comparar o desempenho desta função com o da opção proposta na resposta aceita, consulte este Fiddle e este Fiddle para obter referências.

Versão apenas para navegadores modernos

Nos navegadores modernos, agora você também pode fazer isso:

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

Esta opção é ainda mais rápida. No entanto, infelizmente, ele não funciona em nenhuma versão do Internet Explorer.

Os números na tabela especificam a primeira versão do navegador que suporta totalmente o método:

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

Você também pode adicionar um polyfill para Repeat para navegadores mais antigos

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

Com base nas respostas de Hogan e Zero Trick Pony. Eu acho que isso deve ser rápido e flexível o suficiente para lidar bem com a maioria dos casos de uso:

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

Você pode usar a primeira linha da função como uma linha, se desejar:

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