반복되는 문자로 채워진 가변 길이의 문자열을 만듭니다.

반복되는 문자로 채워진 가변 길이의 문자열을 만듭니다.

---

그래서 내 질문은 다른 사람이 Java 형식으로 여기에서 물었습니다 : Java-지정된 길이의 새 문자열 인스턴스를 만들고 특정 문자로 채 웁니다. 최고의 솔루션?

. . . 하지만 JavaScript와 동등한 것을 찾고 있습니다.

기본적으로 각 필드의 "maxlength"속성에 따라 텍스트 필드를 "#"문자로 동적으로 채우려 고합니다. 따라서 입력에가 있으면 maxlength="3"필드는 "###"으로 채워집니다.

이상적으로 Java와 같은 것이 StringUtils.repeat("#", 10);있지만 지금까지 내가 생각할 수있는 가장 좋은 옵션은 최대 길이에 도달 할 때까지 한 번에 하나씩 "#"문자를 반복하여 추가하는 것입니다. 그보다 더 효율적인 방법이 있다는 느낌을 흔들 수 없습니다.

어떤 아이디어?

참고로 "#"문자는 포커스를 지우고 사용자가 값을 입력하지 않은 경우 흐림시 "리필"해야하기 때문에 입력에서 기본값을 간단히 설정할 수 없습니다. 내가 관심있는 "리필"단계

---

이 작업을 수행하는 가장 좋은 방법은

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

이것은 장황하므로 간결한 구현을 원한다면 순진한 접근 방식으로 갈 수 있습니다. 여전히 Array.join 방식보다 2 배에서 10 배 사이의 성능을 향상 시키며 작은 입력에 대한 배가 구현보다 빠릅니다. 암호:

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

Xdata.length원하는 길이의 문자열 입니다.

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

---

모든 브라우저에서 작동하는 버전

이 함수는 원하는 것을 수행하고 허용 된 답변에 제안 된 옵션보다 훨씬 빠르게 수행합니다.

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

You use it like this :

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

To compare the performance of this function with that of the option proposed in the accepted answer, see this Fiddle and this Fiddle for benchmarks.

Version for moderns browsers only

In modern browsers, you can now also do this :

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

This option is even faster. However, unfortunately it doesn't work in any version of Internet explorer.

The numbers in the table specify the first browser version that fully supports the method :

---

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

You can also add a polyfill for Repeat for older browsers

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

---

A great ES6 option would be to padStart an empty string. Like this:

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

Note: this won't work in IE (without a polyfill).

---

Based on answers from Hogan and Zero Trick Pony. I think this should be both fast and flexible enough to handle well most use cases:

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

---

You can use the first line of the function as a one-liner if you like:

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

참고URL : https://stackoverflow.com/questions/14343844/create-a-string-of-variable-length-filled-with-a-repeated-character