สร้างสตริงที่มีความยาวผันแปรได้เต็มไปด้วยอักขระซ้ำ

ดังนั้นคำถามของฉันถูกถามโดยคนอื่นในรูปแบบ Java ที่นี่: Java - สร้างอินสแตนซ์สตริงใหม่ที่มีความยาวที่ระบุและเต็มไปด้วยอักขระที่เฉพาะเจาะจง ทางออกที่ดีที่สุด?

. . . แต่ฉันกำลังมองหาจาวาสคริปต์ที่เทียบเท่า

โดยทั่วไปฉันต้องการเติมฟิลด์ข้อความด้วยอักขระ "#" แบบไดนามิกโดยยึดตามแอตทริบิวต์ "maxlength" ของแต่ละฟิลด์ ดังนั้นหากมีการป้อนข้อมูลmaxlength="3"แล้วฟิลด์จะถูกเติมด้วย "###"

จะเป็นการดีที่จะมีบางสิ่งบางอย่างเช่น Java StringUtils.repeat("#", 10);แต่จนถึงตอนนี้ตัวเลือกที่ดีที่สุดที่ฉันนึกได้คือการวนซ้ำและผนวกอักขระ "#" ครั้งละหนึ่งตัวจนกว่าจะถึงความยาวสูงสุด ฉันไม่สามารถสั่นคลอนความรู้สึกว่ามีวิธีที่มีประสิทธิภาพมากกว่าที่จะทำ

ความคิดใด ๆ

FYI - ฉันไม่สามารถกำหนดค่าเริ่มต้นในอินพุตได้เพียงเพราะอักขระ "#" จำเป็นต้องล้างโฟกัสและหากผู้ใช้ไม่ได้ป้อนค่าจะต้อง "เติม" เบลอ เป็นขั้นตอน "เติมเงิน" ที่ฉันกังวล

วิธีที่ดีที่สุดในการทำเช่นนี้ (ที่ฉันเคยเห็น) คือ

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

ที่สร้างอาร์เรย์ที่มีความยาวที่กำหนดแล้วรวมกับสตริงที่กำหนดเพื่อทำซ้ำ .join()ฟังก์ชั่นได้รับเกียรตินิยมยาวอาร์เรย์โดยไม่คำนึงว่าองค์ประกอบที่มีค่าที่ได้รับมอบหมายและค่านิยมที่ไม่ได้กำหนดจะกลายเป็นสตริงที่ว่างเปล่า

คุณต้องเพิ่ม 1 ลงในความยาวที่ต้องการเนื่องจากสตริงตัวคั่นจะอยู่ระหว่างองค์ประกอบอาร์เรย์

ลองดูสิ: P

s = '#'.repeat(10)

document.body.innerHTML = s

น่าเสียดายแม้ว่าวิธี Array.join ที่กล่าวถึงในที่นี้จะสั้น แต่ก็ช้ากว่าการปรับใช้แบบสตริงต่อเนื่องประมาณ 10 เท่า มันทำงานโดยเฉพาะอย่างยิ่งไม่ดีกับสตริงขนาดใหญ่ ดูด้านล่างสำหรับรายละเอียดประสิทธิภาพการทำงานเต็มรูปแบบ

ใน Firefox, Chrome, Node.js MacOS, Node.js Ubuntu และ Safari การใช้งานที่เร็วที่สุดที่ฉันทดสอบคือ:

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

นี่คือ verbose ดังนั้นหากคุณต้องการใช้งานสั้น ๆ คุณสามารถไปด้วยวิธีไร้เดียงสา; มันยังคงทำงานได้ดีกว่า 2X ถึง 10 เท่ากว่าวิธี Array.join และเร็วกว่าการใช้งานสองเท่าสำหรับอินพุตขนาดเล็ก รหัส:

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

ข้อมูลเพิ่มเติม:

• ทดสอบความเร็วในเบราว์เซอร์ของคุณเอง
• รหัสที่มาเต็มรูปแบบของการทดสอบความเร็ว
• ผลการทดสอบความเร็ว

ฉันจะสร้างสตริงคงที่แล้วเรียกสตริงย่อยที่มัน

สิ่งที่ต้องการ

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

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

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

เร็วขึ้นเล็กน้อยเช่นกัน

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

ES2015 วิธีที่ง่ายที่สุดคือทำสิ่งที่ชอบ

'X'.repeat(data.length)

Xเป็นสตริงใด ๆdata.lengthเป็นความยาวที่ต้องการ

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

ตัวเลือก ES6 ที่ยอดเยี่ยมคือpadStartสตริงที่ว่างเปล่า แบบนี้:

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

หมายเหตุ: สิ่งนี้จะไม่ทำงานใน IE (โดยไม่ต้องใส่ polyfill)

รุ่นที่ใช้งานได้ในเบราว์เซอร์ทั้งหมด

ฟังก์ชันนี้ทำในสิ่งที่คุณต้องการและทำงานได้เร็วกว่าตัวเลือกที่แนะนำในคำตอบที่ยอมรับ:

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

คุณใช้มันแบบนี้:

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

เพื่อเปรียบเทียบประสิทธิภาพของฟังก์ชั่นนี้กับของตัวเลือกที่เสนอในคำตอบที่ยอมรับดูซอนี้และซอนี้สำหรับการวัดประสิทธิภาพ

รุ่นสำหรับเบราว์เซอร์ที่ทันสมัยเท่านั้น

ในเบราว์เซอร์สมัยใหม่คุณสามารถทำได้ดังนี้:

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

ตัวเลือกนี้เร็วยิ่งขึ้น อย่างไรก็ตามน่าเสียดายที่มันไม่สามารถใช้ได้กับ Internet Explorer ทุกรุ่น

ตัวเลขในตารางระบุเวอร์ชันเบราว์เซอร์แรกที่รองรับวิธีการอย่างสมบูรณ์:

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

คุณยังสามารถเพิ่ม polyfill สำหรับทำซ้ำสำหรับเบราว์เซอร์รุ่นเก่าได้

    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 และ Zero Trick Pony ฉันคิดว่าสิ่งนี้ควรจะรวดเร็วและยืดหยุ่นพอที่จะรองรับกรณีใช้งานส่วนใหญ่ได้ดี:

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

คุณสามารถใช้บรรทัดแรกของฟังก์ชั่นเป็นหนึ่งซับถ้าคุณชอบ:

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