Tekrarlanan bir karakterle dolu, değişken uzunlukta bir dize oluşturma

Yani, sorum burada Java formunda başka biri tarafından sorulmuştur: Java - Belirtilen uzunlukta ve belirli bir karakterle dolu yeni bir String örneği oluşturun. En iyi çözüm?

. . . ama JavaScript eşdeğerini arıyorum.

Temel olarak, her alanın "maxlength" özniteliğine dayalı olarak metin alanlarını dinamik olarak "#" karakterleriyle doldurmak istiyorum. Dolayısıyla, bir girdi varsa maxlength="3"alan "###" ile doldurulur.

İdeal olarak Java gibi bir şey olurdu StringUtils.repeat("#", 10);, ancak şimdiye kadar düşünebileceğim en iyi seçenek, maksimum uzunluğa ulaşılana kadar birer birer "#" karakterleri döngüye sokmak ve eklemektir. Bunu yapmanın daha etkili bir yolu olduğu hissini sallayamıyorum.

Herhangi bir fikir?

FYI - Girişte varsayılan bir değer ayarlayamıyorum çünkü "#" karakterlerinin odakta temizlenmesi gerekiyor ve kullanıcı bir değer girmediyse bulanıklıkta "yeniden doldurulması" gerekecek. Endişelendiğim "doldurma" adımı

Bunu yapmanın en iyi yolu (gördüğüm)

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

Bu, verilen uzunlukta bir dizi oluşturur ve daha sonra tekrarlamak için verilen dizeyle birleştirir. .join()Fonksiyon ne olursa olsun elemanları atanmış değerlere sahip olup olmadığı dizisi uzunluğunu onurlandırıyor ve tanımsız değerleri boş dizeleri olarak oluşturulur.

Ayırıcı dize dizi öğeleri arasında gittiğinden, istenen uzunluğa 1 eklemeniz gerekir .

Bunu deneyin: P

s = '#'.repeat(10)

document.body.innerHTML = s

Ne yazık ki, burada belirtilen Array.join yaklaşımı kısa olmasına rağmen, dize-birleştirme tabanlı bir uygulamadan yaklaşık 10 kat daha yavaştır. Özellikle büyük tellerde kötü performans gösterir. Tüm performans ayrıntıları için aşağıya bakın.

Firefox, Chrome, Node.js MacOS, Node.js Ubuntu ve Safari'de test ettiğim en hızlı uygulama:

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

Bu çok ayrıntılıdır, bu yüzden kısa bir uygulama istiyorsanız naif yaklaşımla gidebilirsiniz; Hala Array.join yaklaşımından 2X ila 10X arasında daha iyi performans gösterir ve ayrıca küçük girdiler için iki katına çıkma uygulamasından daha hızlıdır. Kod:

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

Daha fazla bilgi:

• Kendi tarayıcınızda hız testi yapın
• Hız testinin tam kaynak kodu
• Hız testi sonuçları

Sabit bir dize oluşturmak ve sonra alt dize çağırır.

Gibi bir şey

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

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

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

Biraz daha hızlı.

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

ES2015 en kolay yol gibi bir şey yapmaktır

'X'.repeat(data.length)

Xherhangi bir dize, data.lengthistenen uzunluk.

bkz. https://developer.mozilla.org/tr-TR/docs/Web/JavaScript/Reference/Global_Objects/String/repeat

padStartBoş bir dize için harika bir ES6 seçeneği olabilir . Bunun gibi:

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

Not: Bu IE'de çalışmaz (çoklu dolgu olmadan).

Tüm tarayıcılarda çalışan sürüm

Bu işlev istediğinizi yapar ve kabul edilen cevapta önerilen seçenekten çok daha hızlı performans gösterir:

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

Bu şekilde kullanırsınız:

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

Bu işlevin performansını, kabul edilen yanıtta önerilen seçenekle karşılaştırmak için, karşılaştırmalar için bu Fiddle'a ve bu Fiddle'a bakın.

Yalnızca modern tarayıcılar için sürüm

Modern tarayıcılarda artık şunları da yapabilirsiniz:

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

Bu seçenek daha da hızlı. Ancak, ne yazık ki herhangi bir Internet explorer sürümünde çalışmıyor.

Tablodaki sayılar, yöntemi tam olarak destekleyen ilk tarayıcı sürümünü belirtir:

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

Eski tarayıcılar için Tekrarlama için bir çoklu dolgu da ekleyebilirsiniz

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

Hogan ve Zero Trick Pony'nin cevaplarına dayanarak. Bence bu, çoğu kullanım durumunu iyi işleyebilecek kadar hızlı ve esnek olmalıdır:

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

İsterseniz işlevin ilk satırını tek astar olarak kullanabilirsiniz:

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