Crea una stringa di lunghezza variabile, riempita con un carattere ripetuto

Quindi, la mia domanda è stata posta da qualcun altro nella sua forma Java qui: Java - Crea una nuova istanza String con lunghezza specificata e piena di carattere specifico. Soluzione migliore?

. . . ma sto cercando il suo equivalente JavaScript.

Fondamentalmente, voglio riempire dinamicamente i campi di testo con caratteri "#", in base all'attributo "lunghezza massima" di ciascun campo. Quindi, se un input ha maxlength="3", il campo verrebbe riempito con "###".

Idealmente ci sarebbe qualcosa come Java StringUtils.repeat("#", 10);, ma finora l'opzione migliore che mi viene in mente è quella di passare in rassegna e aggiungere i caratteri "#", uno alla volta, fino a raggiungere la lunghezza massima. Non riesco a scuotere la sensazione che ci sia un modo più efficiente per farlo.

Qualche idea?

Cordiali saluti - Non posso semplicemente impostare un valore predefinito nell'input, perché i caratteri "#" devono essere messi a fuoco e, se l'utente non ha inserito un valore, dovrà essere "riempito" in sfocatura. È il passo di "ricarica" ​​che mi interessa

Il modo migliore per farlo (che ho visto) è

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

Ciò crea un array con la lunghezza data e quindi lo unisce con la stringa data da ripetere. La .join()funzione rispetta la lunghezza dell'array indipendentemente dal fatto che agli elementi siano assegnati valori e i valori indefiniti vengono visualizzati come stringhe vuote.

Devi aggiungere 1 alla lunghezza desiderata perché la stringa di separazione va tra gli elementi dell'array.

Prova questo: P

s = '#'.repeat(10)

document.body.innerHTML = s

Sfortunatamente sebbene l'approccio Array.join menzionato qui sia conciso, è circa 10 volte più lento di un'implementazione basata sulla concatenazione di stringhe. Si comporta particolarmente male su corde di grandi dimensioni. Vedi sotto per i dettagli completi sulle prestazioni.

Su Firefox, Chrome, Node.js MacOS, Node.js Ubuntu e Safari, l'implementazione più veloce che ho provato è stata:

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

Questo è dettagliato, quindi se vuoi un'implementazione concisa potresti seguire un approccio ingenuo; esegue ancora tra 2X e 10X meglio dell'approccio Array.join ed è anche più veloce dell'implementazione doppia per input piccoli. Codice:

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

Ulteriori informazioni:

• Esegui test di velocità nel tuo browser
• Codice sorgente completo del test di velocità
• Risultati del test di velocità

Vorrei creare una stringa costante e quindi chiamare sottostringa su di essa.

Qualcosa di simile a

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

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

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

Anche un po 'più veloce.

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

ES2015 il modo più semplice è fare qualcosa del genere

'X'.repeat(data.length)

Xessendo qualsiasi stringa, data.lengthessendo la lunghezza desiderata.

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

Un'ottima opzione ES6 sarebbe quella di padStartuna stringa vuota. Come questo:

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

Nota: questo non funzionerà in IE (senza un polyfill).

Versione che funziona in tutti i browser

Questa funzione fa quello che vuoi ed esegue molto più velocemente dell'opzione suggerita nella risposta accettata:

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

Lo usi in questo modo:

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

Per confrontare le prestazioni di questa funzione con quelle dell'opzione proposta nella risposta accettata, vedere questo Fiddle e questo Fiddle per i benchmark.

Versione solo per browser moderni

Nei browser moderni, ora puoi anche fare questo:

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

Questa opzione è ancora più veloce. Tuttavia, sfortunatamente non funziona in nessuna versione di Internet Explorer.

I numeri nella tabella specificano la prima versione del browser che supporta completamente il metodo:

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

Puoi anche aggiungere un polifill per Repeat per i browser più vecchi

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

Basato sulle risposte di Hogan e Zero Trick Pony. Penso che questo dovrebbe essere sia veloce che flessibile per gestire bene la maggior parte dei casi d'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)  
    }  
}  

Puoi usare la prima riga della funzione come una riga se ti piace:

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