Cree una cadena de longitud variable, llena con un carácter repetido

Entonces, mi pregunta ha sido formulada por otra persona en su forma de Java aquí: Java: crea una nueva instancia de String con una longitud especificada y llena con un carácter específico. ¿Mejor solución?

. . . pero estoy buscando su equivalente de JavaScript.

Básicamente, quiero llenar dinámicamente los campos de texto con caracteres "#", según el atributo "maxlength" de cada campo. Entonces, si una entrada tiene maxlength="3", el campo se rellenará con "###".

Idealmente, habría algo como el Java StringUtils.repeat("#", 10); , pero, hasta ahora, la mejor opción que se me ocurre es recorrer y agregar los caracteres "#", uno a la vez, hasta alcanzar la longitud máxima. No puedo evitar la sensación de que hay una manera más eficiente de hacerlo que eso.

¿Algunas ideas?

FYI: no puedo simplemente establecer un valor predeterminado en la entrada, porque los caracteres "#" deben borrarse al enfocar y, si el usuario no ingresó un valor, deberán "rellenarse" en el desenfoque. Es el paso de "recarga" que me preocupa

La mejor manera de hacer esto (que he visto) es

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

Eso crea una matriz con la longitud dada, y luego la une con la cadena dada para repetir. La .join()función respeta la longitud de la matriz independientemente de si los elementos tienen valores asignados y los valores indefinidos se representan como cadenas vacías.

Debe agregar 1 a la longitud deseada porque la cadena de separación va entre los elementos de la matriz.

Prueba esto: P

s = '#'.repeat(10)

document.body.innerHTML = s

Desafortunadamente, aunque el enfoque Array.join mencionado aquí es conciso, es aproximadamente 10 veces más lento que una implementación basada en concatenación de cadenas. Se desempeña especialmente mal en cuerdas grandes. Vea a continuación los detalles completos del rendimiento.

En Firefox, Chrome, Node.js MacOS, Node.js Ubuntu y Safari, la implementación más rápida que probé fue:

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

Esto es detallado, por lo que si desea una implementación concisa podría optar por el enfoque ingenuo; todavía funciona entre 2X y 10X mejor que el enfoque Array.join, y también es más rápido que la implementación de duplicación para entradas pequeñas. 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;
}

Más información:

• Ejecute la prueba de velocidad en su propio navegador
• Código fuente completo de prueba de velocidad
• Resultados de la prueba de velocidad

Crearía una cadena constante y luego llamaría a la subcadena.

Algo como

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

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

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

Un poco más rápido también.

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

ES2015 la forma más fácil es hacer algo como

'X'.repeat(data.length)

Xsiendo cualquier cadena, data.lengthsiendo la longitud deseada.

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

Una gran opción de ES6 sería padStartuna cadena vacía. Me gusta esto:

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

Nota: esto no funcionará en IE (sin un polyfill).

Versión que funciona en todos los navegadores.

Esta función hace lo que desea y funciona mucho más rápido que la opción sugerida en la respuesta aceptada:

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

Lo usas así:

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

Para comparar el rendimiento de esta función con el de la opción propuesta en la respuesta aceptada, consulte este violín y este violín para obtener puntos de referencia.

Versión solo para navegadores modernos

En los navegadores modernos, ahora también puede hacer esto:

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

Esta opción es aún más rápida. Sin embargo, desafortunadamente no funciona en ninguna versión de Internet Explorer.

Los números en la tabla especifican la primera versión del navegador que soporta totalmente este 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);   

También puede agregar un polyfill para Repeat para navegadores antiguos

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

Basado en las respuestas de Hogan y Zero Trick Pony. Creo que esto debería ser lo suficientemente rápido y flexible como para manejar bien la mayoría de los 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)  
    }  
}  

Puede usar la primera línea de la función como una línea si desea:

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