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

Une excellente option ES6 serait d'utiliser la méthode padStart avec une chaîne vide. Comme ceci :

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

Remarque : cela ne fonctionnera pas dans IE (sans un polyfill).

Answer 2

Version qui fonctionne dans tous les navigateurs

Cette fonction fait ce que vous voulez et s'exécute beaucoup plus rapidement que l'option suggérée dans la réponse acceptée :

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

Vous l'utilisez comme ceci :

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

Pour comparer les performances de cette fonction avec celles de l'option proposée dans la réponse acceptée, consultez ce Fiddle et ce Fiddle pour des benchmarks.

Version pour les navigateurs modernes uniquement

Dans les navigateurs modernes, vous pouvez maintenant également faire ceci :

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

Cette option est encore plus rapide. Cependant, malheureusement, cela ne fonctionne pas dans n'importe quelle version d'Internet Explorer.

Les chiffres dans le tableau spécifient la première version du navigateur qui prend en charge entièrement la méthode :

Answer 3

Pour les navigateurs Evergreen, cela construira un escalier basé sur un caractère entrant et le nombre de marches à construire.
function StairCase(caractère, entrée) {
    laissez i = 0;
    tandis que (i < entrée) {
        const espaces = " ".repeat(entrée - (i+1));
        const dièses = caractère.repeat(i + 1);
        console.log(espaces + dièses);
        i++;
    }
}

// Implémenter
// Actualiser la console
console.clear();
StairCase("#",6);  

Vous pouvez également ajouter un polyfill pour Repeat pour les anciens navigateurs

    si (!String.prototype.repeat) {
      String.prototype.repeat = function(compter) {
        'use strict';
        si (this == null) {
          jeter un TypeError('impossible de convertir ' + this + ' en objet');
        }
        var str = '' + this;
        compter = +compter;
        si (compter != compter) {
          compter = 0;
        }
        si (compter < 0) {
          jeter une RangeError('le nombre de répétitions doit être non négatif');
        }
        si (compter == Infinity) {
          jeter une RangeError('le nombre de répétitions doit être inférieur à l'infini');
        }
        compter = Math.floor(compter);
        si (str.length == 0 || compter == 0) {
          return '';
        }
        // S'assurer que le nombre de répétitions est un entier sur 31 bits nous permet d'optimiser fortement la
        // partie principale. Mais de toute façon, la plupart des navigateurs actuels (août 2014) ne peuvent pas gérer
        // des chaînes de caractères de 1 << 28 caractères ou plus, donc :
        si (str.length * compter >= 1 << 28) {
          jeter une RangeError('le nombre de répétitions ne doit pas dépasser la taille maximale de la chaîne de caractères');
        }
        var rpt = '';
        pour (;;) {
          si ((compter & 1) == 1) {
            rpt += str;
          }
          compter >>>= 1;
          si (compter == 0) {
            pause;
          }
          str += str;
        }
        // Pourquoi ne pas essayer :
        // return Array(compter + 1).join(this);
        retour rpt;
      }
    }

Answer 4

Basé sur les réponses de Hogan et Zero Trick Pony. Je pense que cela devrait être à la fois assez rapide et assez flexible pour gérer la plupart des cas d'utilisation :

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 5

Vous pouvez utiliser la première ligne de la fonction comme une seule ligne si vous le souhaitez :

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