Créez une chaîne de longueur variable, remplie d'un caractère répété

Question

Donc, ma question a été posée par quelqu'un d'autre dans sa forme Java ici: Java - Créer une nouvelle instance de chaîne avec une longueur spécifiée et remplie d'un caractère spécifique. Meilleure solution?

. . . mais je cherche son équivalent en JavaScript.

En gros, je veux remplir dynamiquement les champs de texte avec des caractères "#", en fonction de l'attribut "maxlength" de chaque champ. Ainsi, si un champ a maxlength="3", alors le champ serait rempli avec "###".

Idéalement, il y aurait quelque chose comme le StringUtils.repeat("#", 10); Java, mais, jusqu'à présent, la meilleure option à laquelle je peux penser est de boucler et d'ajouter les caractères "#" un par un jusqu'à ce que la longueur maximale soit atteinte. Je ne peux pas m'empêcher de penser qu'il existe un moyen plus efficace de le faire que cela.

Des idées?

À noter - Je ne peux pas simplement définir une valeur par défaut dans l'entrée, car les caractères "#" doivent être effacés au focus, et, si l'utilisateur n'a pas saisi de valeur, ils doivent être "remplis" à la perte de focus. C'est l'étape de "remplissage" qui me préoccupe

Answer 1

La meilleure façon de faire cela (que j'ai vue) est

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

Cela crée un tableau de la longueur donnée, puis le joint avec la chaîne donnée pour la répéter. La fonction .join() prend en compte la longueur du tableau indépendamment que les éléments aient des valeurs assignées, et les valeurs non définies sont rendues comme des chaînes vides.

Vous devez ajouter 1 à la longueur désirée car la chaîne de séparation va entre les éléments du tableau.

Answer 2

Essayez ceci :P

s = '#'.repeat(10)

document.body.innerHTML = s

Answer 3

ES2015 la manière la plus simple de faire quelque chose comme

'X'.repeat(data.length)

X étant n'importe quelle chaîne, data.length étant la longueur désirée.

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

Answer 4

Malheureusement, bien que l'approche Array.join mentionnée ici soit concise, elle est environ 10 fois plus lente qu'une implémentation basée sur la concaténation de chaînes. Elle fonctionne particulièrement mal sur de grandes chaînes. Voir ci-dessous pour plus de détails sur les performances.

Sur Firefox, Chrome, Node.js MacOS, Node.js Ubuntu et Safari, l'implémentation la plus rapide que j'ai testée était la suivante :

function repeatChar(count, ch) {
    if (count == 0) {
        return "";
    }
    var count2 = count / 2;
    var result = ch;

    // doubler l'entrée jusqu'à ce qu'elle soit assez longue.
    while (result.length <= count2) {
        result += result;
    }
    // utiliser la méthode substring pour atteindre la longueur précise cible sans utiliser de mémoire supplémentaire
    return result + result.substring(0, count - result.length);
};

Ceci est verbeux, donc si vous voulez une implémentation concise, vous pourriez opter pour l'approche naive ; elle fonctionne toujours entre 2 et 10 fois mieux que l'approche Array.join, et est également plus rapide que l'implémentation en doublant pour de petites entrées. Code :

// approche naive : simplement ajouter les lettres une par une
function repeatChar(count, ch) {
    var txt = "";
    for (var i = 0; i < count; i++) {
        txt += ch;
    }
    return txt;
}

Informations supplémentaires :

• Exécuter le test de vitesse dans votre propre navigateur
• Code source complet du test de vitesse
• Résultats du test de vitesse

Answer 5

Je créerais une chaîne constante et ensuite j'appellerais substring dessus.

Quelque chose comme

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

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

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

Un peu plus rapide aussi.

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