Tạo một chuỗi có độ dài thay đổi, chứa đầy một ký tự lặp lại

Vì vậy, câu hỏi của tôi đã được người khác hỏi ở dạng Java ở đây: Java - Tạo một cá thể Chuỗi mới với độ dài được chỉ định và chứa đầy ký tự cụ thể. Giải pháp tốt nhất?

. . . nhưng tôi đang tìm kiếm JavaScript tương đương.

Về cơ bản, tôi muốn tự động điền vào các trường văn bản với các ký tự "#", dựa trên thuộc tính "maxlength" của từng trường. Vì vậy, nếu một đầu vào có maxlength="3", thì trường sẽ được điền "###".

Lý tưởng nhất là sẽ có một cái gì đó giống như Java StringUtils.repeat("#", 10);, nhưng, cho đến nay, tùy chọn tốt nhất mà tôi có thể nghĩ đến là lặp qua và nối các ký tự "#", mỗi lần một, cho đến khi đạt được độ dài tối đa. Tôi không thể lay chuyển được cảm giác rằng có một cách hiệu quả hơn để làm điều đó hơn thế.

Có ý kiến ​​gì không?

FYI - Tôi không thể đơn giản đặt giá trị mặc định trong đầu vào, bởi vì các ký tự "#" cần xóa tiêu điểm và, nếu người dùng không nhập giá trị, sẽ cần phải "nạp lại" khi bị mờ. Đó là bước "nạp tiền" mà tôi quan tâm

Cách tốt nhất để làm điều này (mà tôi đã thấy) là

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

Điều đó tạo ra một mảng với độ dài cho trước, và sau đó nối nó với chuỗi đã cho để lặp lại. Các .join()chức năng tôn độ dài mảng bất kể các yếu tố có giá trị được giao, và các giá trị không xác định được trả lại như chuỗi rỗng.

Bạn phải thêm 1 vào độ dài mong muốn vì chuỗi phân tách đi giữa các thành phần mảng.

Hãy thử xem: P

s = '#'.repeat(10)

document.body.innerHTML = s

Thật không may, mặc dù cách tiếp cận Array.join được đề cập ở đây rất ngắn gọn, nhưng nó chậm hơn khoảng 10 lần so với cách triển khai dựa trên chuỗi nối. Nó thực hiện đặc biệt xấu trên các chuỗi lớn. Xem bên dưới để biết chi tiết hiệu suất đầy đủ.

Trên Firefox, Chrome, Node.js MacOS, Node.js Ubuntu và Safari, cách triển khai nhanh nhất tôi đã thử nghiệm là:

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

Đây là dài dòng, vì vậy nếu bạn muốn thực hiện ngắn gọn, bạn có thể đi với cách tiếp cận ngây thơ; nó vẫn thực hiện betweeb 2X đến 10X tốt hơn so với cách tiếp cận Array.join và cũng nhanh hơn so với triển khai nhân đôi cho các đầu vào nhỏ. Mã số:

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

Thêm thông tin:

• Chạy kiểm tra tốc độ trong trình duyệt của riêng bạn
• Mã nguồn đầy đủ của bài kiểm tra tốc độ
• Kết quả kiểm tra tốc độ

Tôi sẽ tạo một chuỗi không đổi và sau đó gọi chuỗi con trên đó.

Cái gì đó như

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

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

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

Nhanh hơn một chút.

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

ES2015 cách dễ nhất là làm một cái gì đó như

'X'.repeat(data.length)

Xlà bất kỳ chuỗi, data.lengthlà độ dài mong muốn.

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

Một tùy chọn ES6 tuyệt vời sẽ là padStartmột chuỗi trống. Như thế này:

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

Lưu ý: điều này sẽ không hoạt động trong IE (không có polyfill).

Phiên bản hoạt động trong tất cả các trình duyệt

Hàm này thực hiện những gì bạn muốn và thực hiện nhanh hơn rất nhiều so với tùy chọn được đề xuất trong câu trả lời được chấp nhận:

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

Bạn sử dụng nó như thế này:

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

Để so sánh hiệu suất của chức năng này với tùy chọn được đề xuất trong câu trả lời được chấp nhận, hãy xem Fiddle và Fiddle này để biết điểm chuẩn.

Phiên bản chỉ dành cho trình duyệt hiện đại

Trong các trình duyệt hiện đại, bây giờ bạn cũng có thể làm điều này:

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

Tùy chọn này thậm chí còn nhanh hơn. Tuy nhiên, thật không may, nó không hoạt động trong bất kỳ phiên bản Internet explorer nào.

Các số trong bảng chỉ định phiên bản trình duyệt đầu tiên hỗ trợ đầy đủ phương thức:

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

Bạn cũng có thể thêm một polyfill cho Lặp lại cho các trình duyệt cũ hơn

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

Dựa trên câu trả lời từ Hogan và Zero Trick Pony. Tôi nghĩ rằng điều này nên vừa đủ nhanh và linh hoạt để xử lý tốt hầu hết các trường hợp sử dụng:

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

Bạn có thể sử dụng dòng đầu tiên của hàm dưới dạng một lớp lót nếu bạn muốn:

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