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

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

. . . mais je cherche son équivalent JavaScript.

Fondamentalement, je souhaite remplir dynamiquement les champs de texte avec des caractères "#", en fonction de l'attribut "maxlength" de chaque champ. Donc, si une entrée a maxlength="3", alors le champ sera rempli avec "###".

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

Des idées?

FYI - Je ne peux pas simplement définir une valeur par défaut dans l'entrée, car les caractères "#" doivent être effacés lors de la mise au point et, si l'utilisateur n'a pas entré de valeur, ils devront être "remplis" sur le flou. C'est l'étape de "recharge" qui me préoccupe

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 avec la longueur donnée, puis le joint à la chaîne donnée à répéter. La .join()fonction honore la longueur du tableau indépendamment du fait que les éléments aient ou non des valeurs assignées, et les valeurs non définies sont rendues sous forme de chaînes vides.

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

Essayez ceci: P

s = '#'.repeat(10)

document.body.innerHTML = s

Malheureusement, bien que l'approche Array.join mentionnée ici soit laconique, elle est environ 10 fois plus lente qu'une implémentation basée sur la concaténation de chaînes. Il fonctionne particulièrement mal sur les grosses cordes. 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:

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

C'est verbeux, donc si vous voulez une implémentation laconique, vous pouvez opter pour l'approche naïve; il fonctionne toujours entre 2X et 10X mieux que l'approche Array.join, et est également plus rapide que l'implémentation du doublement pour les petites entrées. Code:

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

Informations complémentaires:

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

Je créerais une chaîne constante, puis j'appellerais une sous-chaîne dessus.

Quelque chose comme

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

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

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

Un peu plus vite aussi.

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

ES2015, le moyen le plus simple est 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

Une excellente option ES6 serait d'utiliser padStartune chaîne vide. Comme ça:

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

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

Version qui fonctionne dans tous les navigateurs

Cette fonction fait ce que vous voulez et fonctionne 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, voir ce Fiddle et ce Fiddle pour les repères.

Version pour les navigateurs modernes uniquement

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

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

Cette option est encore plus rapide. Cependant, malheureusement, cela ne fonctionne dans aucune version d'Internet Explorer.

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

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

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

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

Basé sur les réponses de Hogan et Zero Trick Pony. Je pense que cela devrait être à la fois suffisamment rapide et flexible pour bien 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)  
    }  
}  

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

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