quitar - split javascript array

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

Question

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

. . . pero estoy buscando su equivalente en JavaScript.

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

Idealmente, habría algo como Java StringUtils.repeat("#", 10); , pero, hasta ahora, la mejor opción que puedo pensar es recorrer y agregar los caracteres "#", uno a la vez, hasta alcanzar la longitud máxima. No puedo dejar de sentir 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 "#" necesitan despejarse en el enfoque, y, si el usuario no ingresó un valor, será necesario "rellenar" el desenfoque. Es el paso de "relleno" lo que me preocupa

Answer 1

Versión que funciona en todos los navegadores

Esta función hace lo que quiere, 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 la de la opción propuesta en la respuesta aceptada, consulte este Fiddle y este Fiddle para los puntos de referencia.

Versión para navegadores modernos solamente

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 :

Answer 2

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

Answer 3

Crearía una cadena constante y luego llamaría una subcadena sobre ella.

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

Answer 4

Desafortunadamente, aunque el enfoque Array.join mencionado aquí es breve, es aproximadamente 10 veces más lento que una implementación basada en concatenación de cadenas. Se desempeña especialmente mal en cadenas grandes. Vea a continuación para obtener todos los detalles de 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 quieres una implementación concisa, puedes ir con el enfoque ingenuo; todavía se comporta entre 2X a 10X mejor que el enfoque Array.join, y también es más rápido que la implementación de duplicación para pequeñas 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;
}

Más información:

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

Answer 5

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 función .join() respeta la longitud de la matriz, independientemente de si los elementos tienen valores asignados, y los valores no definidos 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.

Answer 6

Ok, creo que esto es lo que estás buscando. Puede ver cómo se implementó en node.js src:

function repeatString(str, len) {
return Array.apply(null, {
length: len + 1
}).join(str).slice(0, len)
}

Answer 7

Prueba esto: P

s = ''#''.repeat(10)
document.body.innerHTML = s

Answer 8

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

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

Answer 9

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 más 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;
}
}