정해진 길이에 도달하기 위해 문자열을 채울 수있는 JavaScript 함수가 있습니까?


272

값을 가져 와서 주어진 길이로 채울 수있는 JavaScript 함수가 필요합니다 (공백이 필요하지만 모든 것이 가능합니다). 나는 이것을 찾았다:

암호:

String.prototype.pad = function(l, s, t){
    return s || (s = " "), (l -= this.length) > 0 ? (s = new Array(Math.ceil(l / s.length)
        + 1).join(s)).substr(0, t = !t ? l : t == 1 ? 0 : Math.ceil(l / 2))
        + this + s.substr(0, l - t) : this;
};

예:

<script type="text/javascript">
//<![CDATA[

var s = "Jonas";
document.write(
    '<h2>S = '.bold(), s, "</h2>",
    'S.pad(20, "[]", 0) = '.bold(), s.pad(20, "[]", 0), "<br />",
    'S.pad(20, "[====]", 1) = '.bold(), s.pad(20, "[====]", 1), "<br />",
    'S.pad(20, "~", 2) = '.bold(), s.pad(20, "~", 2)
);

//]]>
</script>

그러나 나는 그것이 무엇을하고 있는지 알지 못하며 나에게는 효과가없는 것 같습니다.


답변:


515

나는이 해결책을 여기 에서 찾았고 이것은 훨씬 간단합니다.

var n = 123

String("00000" + n).slice(-5); // returns 00123
("00000" + n).slice(-5); // returns 00123
("     " + n).slice(-5); // returns "  123" (with two spaces)

그리고 여기에 문자열 객체를 확장했습니다.

String.prototype.paddingLeft = function (paddingValue) {
   return String(paddingValue + this).slice(-paddingValue.length);
};

그것을 사용하는 예 :

function getFormattedTime(date) {
  var hours = date.getHours();
  var minutes = date.getMinutes();

  hours = hours.toString().paddingLeft("00");
  minutes = minutes.toString().paddingLeft("00");

  return "{0}:{1}".format(hours, minutes);
};

String.prototype.format = function () {
    var args = arguments;
    return this.replace(/{(\d+)}/g, function (match, number) {
        return typeof args[number] != 'undefined' ? args[number] : match;
    });
};

"15:30"형식으로 시간을 반환합니다


11
내가 찾은 가장 읽기 쉽고 간결한 접근 방식; 일반적으로 프로토 타입 확장을 방해하지 않을 정도로 간단합니다 (적어도 응용 프로그램에서 몇 가지 용도로만 사용). 잘 했어.
brichins

32
이 솔루션은 슬라이스 인수보다 긴 문자열을 줄입니다 (예 : 5 자).
Denis V

1
안녕하세요 야 니브. 알고리즘을 수정하는 것이 좋습니다. 그러나 내 경우에는 무언가를 형식화하려고 할 때 항상 처리 해야하는 값에 대한 최소 사양이 있으며이 경우 사양 이이 문제를 해결하기 때문에 요구 사항이 항상이 문제보다 우선합니다. 예를 들어 서식을 지정할 전화 번호가 있고 캐나다에서만 전화를 처리하는 경우 서식을 지정하기 전에 전화 번호가 10 자인지 확인합니다. 어쨌든 귀하의 솔루션도 훌륭합니다. :)
Samuel

1
이 작업을 많이 수행하는 경우 (예 : 페이지 또는 다른 응용 프로그램의 일종의 목록에 긴 값 목록을 채우는 경우) stackoverflow.com/questions/2686855/… 에서 더 빠른 방법으로 답변을 참조하십시오.
Shyam Habarakada

6
이 심하게 JS를 사용하도록 업데이트 할 필요가 String libs와 String.padStart()String.padEnd()왼쪽 / 오른쪽 패딩.
SudoKid

119

더 빠른 방법

예를 들어 배열의 값을 채우는 등의 작업을 반복적으로 수행하고 성능이 중요한 요소 인 경우 다음 접근 방식 은 현재 웹에서 논의중인 다른 솔루션에 비해 속도 ( jsPerf )가 거의 100 배나 유리 합니다. 기본 아이디어는 버퍼로 사용하기 위해 패드 기능에 완전히 채워진 빈 문자열을 제공한다는 것입니다. pad 함수는이 미리 채워진 문자열 (하나의 문자열 연결)에 추가 될 문자열에 추가 한 다음 원하는 길이로 결과를 슬라이스하거나 잘라냅니다.

function pad(pad, str, padLeft) {
  if (typeof str === 'undefined') 
    return pad;
  if (padLeft) {
    return (pad + str).slice(-pad.length);
  } else {
    return (str + pad).substring(0, pad.length);
  }
}

예를 들어, 숫자를 10 자리 길이로 0으로 채우려면

pad('0000000000',123,true);

문자열을 공백으로 채우려면 전체 문자열이 255 자입니다.

var padding = Array(256).join(' '), // make a string of 255 spaces
pad(padding,123,true);

성능 테스트

여기서 jsPerf 테스트를 참조 하십시오 .

그리고 이것은 string.repeat수정 된 JsPerf에 표시된 것처럼 ES6보다 2 배 빠릅니다 .


5
+1 StackOverflow와 관련된 문제의 일부는 중재자가 명백히 우수한 답변에 따라 투표를 변경할 수 없다는 것입니다. 이것은 그러한 경우 중 하나입니다.
Jason Sebring

1
다른 사람이 나중에 jsPerf (위에 추가 된 링크)에서 입증 된 것처럼이 접근법은 ES6 string.repeat방법 보다 ~ 2 배 빠릅니다 . 따라서 많은 문자열 패딩을 수행하는 경우 반드시 시도하십시오.
Shyam Habarakada

5
Jason의 의견에 혼동됩니다.이 답변과 허용되는 답변은 어떻게 다릅니 까?
corwin.amber

1
나는 당신의 jsPerf를 보았다. 이러한 테스트는 함수와 while () 루프를 사용하는 것으로, 다른 높은 답변은 사용하지 않습니다. 그것이 더 빠르다는 것을 확신하지 못합니까?
HoldOffHunger

48

http://www.webtoolkit.info/javascript_pad.html

/**
*
*  Javascript string pad
*  http://www.webtoolkit.info/
*
**/

var STR_PAD_LEFT = 1;
var STR_PAD_RIGHT = 2;
var STR_PAD_BOTH = 3;

function pad(str, len, pad, dir) {

    if (typeof(len) == "undefined") { var len = 0; }
    if (typeof(pad) == "undefined") { var pad = ' '; }
    if (typeof(dir) == "undefined") { var dir = STR_PAD_RIGHT; }

    if (len + 1 >= str.length) {

        switch (dir){

            case STR_PAD_LEFT:
                str = Array(len + 1 - str.length).join(pad) + str;
            break;

            case STR_PAD_BOTH:
                var padlen = len - str.length;
                var right = Math.ceil( padlen / 2 );
                var left = padlen - right;
                str = Array(left+1).join(pad) + str + Array(right+1).join(pad);
            break;

            default:
                str = str + Array(len + 1 - str.length).join(pad);
            break;

        } // switch

    }

    return str;

}

훨씬 더 읽기 쉽습니다.


1
패드가 공간 일 때 작동하지 않는 것 같습니다 :pad("hello", 20) = "hello "
Cillié Malan

40

여기에 재귀 접근 방식이 있습니다.

function pad(width, string, padding) { 
  return (width <= string.length) ? string : pad(width, padding + string, padding)
}

예를 들면 ...

pad(5, 'hi', '0')
=> "000hi"

7
정수 곱셈에 대한 재귀적인 정의도 있습니다. 항상 재귀에 '저주'가 있다는 것을 기억하십시오.
flow

32
길거리에서 일각 고래와 술에 취한 사람도 있지만 둘 다 관련이 없습니다. 재귀의 저주는 프로그래머가 언제 적절한 지 알지 못하는 경우에만 적용됩니다.
hypno7oad

12
"재귀의 저주는 프로그래머가 언제 적절한 지 알지 못하는 경우에만 적용됩니다." 간단한 끈 패드 기능 등.
Danation

이것은 매우 우아하고 내 유스 케이스에 완벽하게 작동했습니다. 텍스트를 정렬하기 위해 공백을 채워야하는 경우 가장 긴 문자열의 길이를 입력하십시오 =)
Damon Aw

12
우아하지만 함수를 반복 할 때마다 새 문자열을 만듭니다. 이 함수는 O (n)이며 @Samuel이 가장 많이 사용하는 솔루션은 O (1)입니다. 둘 다 우아하지만 하나는 훨씬 더 효율적입니다. 그것은 깔끔한 접근법이며 다른 언어에서는 더 빠를 수도 있습니다.
호감

40

String.prototype.padStart()그리고 String.prototype.padEnd()현재 TC39 후보의 제안은 다음과 같습니다 참조 github.com/tc39/proposal-string-pad-start-end을 (4 월 2016 파이어 폭스에서만 사용할 수 있습니다; polyfill이 가능).


13
현재 모든 (현대) 브라우저에서 지원 : developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
Sphinxxx

: 게으른 들어 myString.padStart(padLength [, padString])myString.padEnd(padLength [, padString])
요한 Dettmar

1
모든 최신 브라우저에서 지원되므로 사용 예를 추가하십시오. 권장해야합니다.
Franklin Yu

이런 쓰레기, 오늘까지 어떻게 들었어? 이것은 정답입니다.
electrovir

29

ECMAScript 2017은 padStart 메소드를 문자열 프로토 타입에 추가합니다. 이 방법은 주어진 길이에 공백이있는 문자열을 채 웁니다. 이 방법은 또한 여백에 공백 대신 사용되는 선택적 문자열을 사용합니다.

'abc'.padStart(10);         // "       abc"
'abc'.padStart(10, "foo");  // "foofoofabc"
'abc'.padStart(6,"123465"); // "123abc"
'abc'.padStart(8, "0");     // "00000abc"
'abc'.padStart(1);          // "abc"

같은 방식으로 작동하는 padEnd 메소드도 추가되었습니다.

브라우저 호환성 (및 유용한 polyfill) 은이 링크를 참조하십시오 .


요즘 최고의 답변 입니다! 2019 년!
Peter Krauss

22

ECMAScript 6 메소드 String # repeat를 사용하면 다음 과 같은 간단한 패드 함수가 가능합니다.

String.prototype.padLeft = function(char, length) { 
    return char.repeat(Math.max(0, length - this.length)) + this;
}

String#repeat현재 Firefox 및 Chrome에서만 지원됩니다. 다른 구현의 경우 다음과 같은 간단한 폴리 필을 고려할 수 있습니다.

String.prototype.repeat = String.prototype.repeat || function(n){ 
    return n<=1 ? this : (this + this.repeat(n-1)); 
}

Node.js에서 일하는 사람들을 위해 String.repeat도 지원됩니다.
jkt123

15

ECMAScript 6 방법 String # repeatArrow functions 을 사용하면 pad 함수는 다음과 같이 간단합니다.

var leftPad = (s, c, n) => c.repeat(n - s.length) + s;
leftPad("foo", "0", 5); //returns "00foo"

jsfiddle

편집 : 의견에서 제안 :

const leftPad = (s, c, n) => n - s.length > 0 ? c.repeat(n - s.length) + s : s;

이런 식으로, s.length이보다 큰 경우 오류가 발생하지 않습니다.n

edit2 : 의견의 제안 :

const leftPad = (s, c, n) =>{ s = s.toString(); c = c.toString(); return s.length > n ? s : c.repeat(n - s.length) + s; }

이런 식으로 문자열과 문자열이 아닌 함수를 모두 사용할 수 있습니다.


1
이것은 좋지만 던질 것 s.length보다 큰 경우 입니다 n. 제안 :let leftPad = (s, c, n) => n - s.length > 0 ? c.repeat(n - s.length) + s : s;
David G

문자열이 아닌 경우에는 작동하지 않습니다. 에서처럼 leftPad(12, ' ', 5). 나는 그것이 괜찮을 수도 있다는 것을 엄격히 알고 있지만 아마도 가장 일반적인 유스 케이스 중 하나 일 것입니다 (패딩 번호). 아마 function leftPad(s, c, n) { s = s.toString(); return s.length > len ? s : c.repeat(n - s.length) + s; }. 사용 function방법은 leftPad가 파일의 맨 아래에있을 수 있습니다. 그렇지 않으면 당신은 틀림없이 사용해야 const하지 var않고 let.
gman

@gman이 제안에 감사하지만 변수는 무엇 len입니까?
InsOp

Doh lenn
gman

14

이 두 가지 솔루션의 핵심 요령은 array주어진 크기 (원하는 길이보다 하나 이상) 로 인스턴스를 만든 다음 즉시 join()메소드를 호출하여을 만드는 것 string입니다. 이 join()메소드는 패딩 string(공백)에 전달 됩니다. array가 비어 있기 때문에 빈 셀은 하나의 결과 strings에 결합하는 과정 에서 빈 셀로 렌더링되며 패딩 만 남습니다. 정말 좋은 기술입니다.arraystring


10

기본값이있는 패드

나는 시간 변환 / 숫자 패딩을 위해 대부분 padLeft가 필요하다는 것을 알았습니다.

그래서 나는이 기능을 썼다.

function padL(a,b,c){//string/number,length=2,char=0
 return (new Array(b||2).join(c||0)+a).slice(-b)
}

이 간단한 함수는 숫자 또는 문자열을 지원합니다 을 입력으로

기본 패드는 2 자입니다.

기본 문자는 0입니다

그래서 간단히 쓸 수 있습니다

padL(1);
// 01

두 번째 인수를 추가하면 (패드 너비)

padL(1,3);
// 001

세 번째 매개 변수 (패드 문자)

padL('zzz',10,'x');
// xxxxxxxzzz

정의되지 않은 값이나 길이가 0 인 문자열을 전달하면 @BananaAcid를 편집 하십시오 0undefined.

제안한대로

function padL(a,b,c){//string/number,length=2,char=0
 return (new Array((b||1)+1).join(c||0)+(a||'')).slice(-(b||2))
}

그러나 이것은 더 짧은 방법으로도 달성 될 수 있습니다.

function padL(a,b,c){//string/number,length=2,char=0
 return (new Array(b||2).join(c||0)+(a||c||0)).slice(-b)
}

함께 작동합니다 :

padL(0)
padL(NaN)
padL('')
padL(undefined)
padL(false)

그리고 두 가지 방법으로 패딩 할 수 있기를 원한다면 :

function pad(a,b,c,d){//string/number,length=2,char=0,0/false=Left-1/true=Right
return a=(a||c||0),c=new Array(b||2).join(c||0),d?(a+c).slice(0,b):(c+a).slice(-b)
}

슬라이스를 사용하지 않고 더 짧은 방법으로 쓸 수 있습니다.

function pad(a,b,c,d){
 return a=(a||c||0)+'',b=new Array((++b||3)-a.length).join(c||0),d?a+b:b+a
}
/*

Usage:

pad(
 input // (int or string) or undefined,NaN,false,empty string
       // default:0 or PadCharacter
 // optional
 ,PadLength // (int) default:2
 ,PadCharacter // (string or int) default:'0'
 ,PadDirection // (bolean) default:0 (padLeft) - (true or 1) is padRight 
)

*/

이제 2로 'verylongword'를 채우려 고하면 내 문제가 아닙니다.


내가 당신에게 팁을 주었다고 말했다.

대부분의 경우 패드를 사용하면 동일한 값을 N 번 수행합니다.

루프 내에서 모든 유형의 함수를 사용하면 루프 속도가 느려집니다 !!!

따라서 긴 목록 안에 일부 숫자를 남겨두고 싶다면이 간단한 작업을 수행하는 함수를 사용하지 마십시오.

이 같은 것을 사용하십시오 :

var arrayOfNumbers=[1,2,3,4,5,6,7],
    paddedArray=[],
    len=arrayOfNumbers.length;
while(len--){
 paddedArray[len]=('0000'+arrayOfNumbers[len]).slice(-4);
}

배열 내부의 숫자를 기반으로 최대 패딩 크기를 모르는 경우.

var arrayOfNumbers=[1,2,3,4,5,6,7,49095],
    paddedArray=[],
    len=arrayOfNumbers.length;

// search the highest number
var arrayMax=Function.prototype.apply.bind(Math.max,null),
// get that string length
padSize=(arrayMax(arrayOfNumbers)+'').length,
// create a Padding string
padStr=new Array(padSize).join(0);
// and after you have all this static values cached start the loop.
while(len--){
 paddedArray[len]=(padStr+arrayOfNumbers[len]).slice(-padSize);//substr(-padSize)
}
console.log(paddedArray);

/*
0: "00001"
1: "00002"
2: "00003"
3: "00004"
4: "00005"
5: "00006"
6: "00007"
7: "49095"
*/

아주 좋아요! 메모와 마찬가지로 동일한 결과를 얻었습니다. 이것은 문자열을 주어진 최대 길이로 연결하고 빈 문자열은 하나의 문자가 너무 짧고 정의되지 않은 str은 '정의되지 않은'벌을 사용하고 스플 라이스는 오류를 던질 수 있습니다 -결합. return (new Array((b||1)+1).join(c||0)+(a||'')).slice(-(b||2)). 그리고 항상 그렇듯이 여러분은 이해하지 못하는 코드 만 복사하지 마십시오.
BananaAcid

1
(새로운 배열 (b || 2) .join (c || 0) + (a || c || 0)). slice (-b) ... 더 짧은
cocco


9

사무엘의 생각을 여기에서 그리고 오래된 SQL 스크립트를 기억하십시오.

a=1234;
'0000'.slice(a.toString().length)+a;

내가 상상할 수있는 모든 경우에 작동합니다.

a=     1 result  0001
a=    12 result  0012
a=   123 result  0123
a=  1234 result  1234
a= 12345 result 12345
a=  '12' result  0012

5

새로운 자바 스크립트 버전에서 패딩 문자열이 보완되었습니다.

str.padStart(targetLength [, padString])

https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/String/padStart

자신의 기능을 원한다면이 예제를 확인하십시오.

const myString = 'Welcome to my house';
String.prototype.padLeft = function(times = 0, str = ' ') {
    return (Array(times).join(str) + this);
}
console.log(myString.padLeft(12, ':'));
//:::::::::::Welcome to my house

이 답변은 다른 여러 답변에서 언급되었으므로 새로운 정보를 추가하지 않는 중복입니다. 대답하기 전에 검색하십시오.
Franklin Yu

이것은 완전한 서명을 가진 첫 번째 것입니다. 그리고 오늘 현재 유일한 답이어야합니다.
d_f

4

내가 사용하는 간단한 기능은 다음과 같습니다.

var pad=function(num,field){
    var n = '' + num;
    var w = n.length;
    var l = field.length;
    var pad = w < l ? l-w : 0;
    return field.substr(0,pad) + n;
};

예를 들면 다음과 같습니다.

pad    (20,'     ');    //   20
pad   (321,'     ');    //  321
pad (12345,'     ');    //12345
pad (   15,'00000');    //00015
pad (  999,'*****');    //**999
pad ('cat','_____');    //__cat  

4

짧은 방법 :

(x=>(new Array(int-x.length+1)).join(char)+x)(String)

예:

(x=>(new Array(6-x.length+1)).join("0")+x)("1234")

반환 : "001234"


1
아마도 String.prototype.padStart()더 쉬울 것입니다.
Max Peng

3

es7 은 바로 초안 및 제안이지만 사양과의 호환성을 추적하려면 패드 기능에 다음이 필요합니다.

  1. 다중 문자 패드 지원.
  2. 입력 문자열을 자르지 마십시오
  3. 패드는 기본적으로 공간

내 polyfill 라이브러리에서 프로토 타입 확장에 대한 실사를 적용하십시오.

// Tests
'hello'.lpad(4) === 'hello'
'hello'.rpad(4) === 'hello'
'hello'.lpad(10) === '     hello'
'hello'.rpad(10) === 'hello     '
'hello'.lpad(10, '1234') === '41234hello'
'hello'.rpad(10, '1234') === 'hello12341'

String.prototype.lpad || (String.prototype.lpad = function( length, pad )
{
    if( length < this.length ) return this;

    pad = pad || ' ';
    let str = this;

    while( str.length < length )
    {
        str = pad + str;
    }

    return str.substr( -length );
});

String.prototype.rpad || (String.prototype.rpad = function( length, pad )
{
    if( length < this.length ) return this;

    pad = pad || ' ';
    let str = this;

    while( str.length < length )
    {
        str += pad;
    }

    return str.substr( 0, length );
});

3

기본적으로 한 줄의 코드로 간단한 대답이 있습니다.

var value = 35 // the numerical value
var x = 5 // the minimum length of the string

var padded = ("00000" + value).substr(-x);

패딩의 문자 수 (여기서는 0)는 최소한 의도 한 최소 길이 이상이어야합니다. 따라서 실제로 한 줄에 넣으면이 경우 "00035"의 결과를 얻을 수 있습니다.

var padded = ("00000" + 35).substr(-5);

2

배열 조작은 간단한 문자열 연결에 비해 실제로 느립니다. 물론 사용 사례에 대한 벤치 마크입니다.

function(string, length, pad_char, append) {
    string = string.toString();
    length = parseInt(length) || 1;
    pad_char = pad_char || ' ';

    while (string.length < length) {
        string = append ? string+pad_char : pad_char+string;
    }
    return string;
};

2

@Daniel LaFavers의 답변 변형입니다 .

var mask = function (background, foreground) {
  bg = (new String(background));
  fg = (new String(foreground));
  bgl = bg.length;
  fgl = fg.length;
  bgs = bg.substring(0, Math.max(0, bgl - fgl));
  fgs = fg.substring(Math.max(0, fgl - bgl));
  return bgs + fgs;
};

예를 들면 다음과 같습니다.

mask('00000', 11  );   // '00011'
mask('00011','00' );   // '00000'
mask( 2     , 3   );   // '3'
mask('0'    ,'111');   // '1'
mask('fork' ,'***');   // 'f***'
mask('_____','dog');   // '__dog'

2

2014 년이며 Javascript 문자열 패딩 기능을 제안합니다. 하아!

맨손 : 공백이있는 오른쪽 패드

function pad ( str, length ) {
    var padding = ( new Array( Math.max( length - str.length + 1, 0 ) ) ).join( " " );
    return str + padding;
}

팬시 : 옵션 패드

/**
 * @param {*}       str                         input string, or any other type (will be converted to string)
 * @param {number}  length                      desired length to pad the string to
 * @param {Object}  [opts]
 * @param {string}  [opts.padWith=" "]          char to use for padding
 * @param {boolean} [opts.padLeft=false]        whether to pad on the left
 * @param {boolean} [opts.collapseEmpty=false]  whether to return an empty string if the input was empty
 * @returns {string}
 */
function pad ( str, length, opts ) {
    var padding = ( new Array( Math.max( length - ( str + "" ).length + 1, 0 ) ) ).join( opts && opts.padWith || " " ),
        collapse = opts && opts.collapseEmpty && !( str + "" ).length;
    return collapse ? "" : opts && opts.padLeft ? padding + str : str + padding;
}

사용법 (팬시) :

pad( "123", 5 );
// returns "123  "

pad( 123, 5 );
// returns "123  " - non-string input

pad( "123", 5, { padWith: "0", padLeft: true } );
// returns "00123"

pad( "", 5 );
// returns "     "

pad( "", 5, { collapseEmpty: true } );
// returns ""

pad( "1234567", 5 );
// returns "1234567"


2

비용이 많이 들기 때문에 재귀를 피하는 것이 좋습니다.

function padLeft(str,size,padwith) {
	if(size <= str.length) {
        // not padding is required.
		return str;
	} else {
        // 1- take array of size equal to number of padding char + 1. suppose if string is 55 and we want 00055 it means we have 3 padding char so array size should be 3 + 1 (+1 will explain below)
        // 2- now join this array with provided padding char (padwith) or default one ('0'). so it will produce '000'
        // 3- now append '000' with orginal string (str = 55), will produce 00055

        // why +1 in size of array? 
        // it is a trick, that we are joining an array of empty element with '0' (in our case)
        // if we want to join items with '0' then we should have at least 2 items in the array to get joined (array with single item doesn't need to get joined).
        // <item>0<item>0<item>0<item> to get 3 zero we need 4 (3+1) items in array   
		return Array(size-str.length+1).join(padwith||'0')+str
	}
}

alert(padLeft("59",5) + "\n" +
     padLeft("659",5) + "\n" +
     padLeft("5919",5) + "\n" +
     padLeft("59879",5) + "\n" +
     padLeft("5437899",5));


1

다음은 사용자 지정 symble로 지정된 수의 패딩을 추가하는 JavaScript 함수입니다. 이 함수는 세 가지 매개 변수를 사용합니다.

    padMe-> 문자열 또는 숫자를 왼쪽 패드로
    패드-> 패드 수
    padSymble-> 사용자 지정 symble, 기본값은 "0" 

    function leftPad(padMe, pads, padSymble) {
         if( typeof padMe === "undefined") {
             padMe = "";
         }
         if (typeof pads === "undefined") {
             pads = 0;
         }
         if (typeof padSymble === "undefined") {
             padSymble = "0";
         }

         var symble = "";
         var result = [];
         for(var i=0; i < pads ; i++) {
            symble += padSymble;
         }
        var length = symble.length - padMe.toString().length;
        result = symble.substring(0, length);
        return result.concat(padMe.toString());
    }
/ * 결과는 다음과 같습니다.

> 왼쪽 패드 (1)
"1"
> 왼쪽 패드 (1, 4)
"0001"
> 왼쪽 패드 (1, 4, "0")
"0001"
> leftPad (1, 4, "@")
"@@@1"

* /

1
/**************************************************************************************************
Pad a string to pad_length fillig it with pad_char.
By default the function performs a left pad, unless pad_right is set to true.

If the value of pad_length is negative, less than, or equal to the length of the input string, no padding takes place.
**************************************************************************************************/
if(!String.prototype.pad)
String.prototype.pad = function(pad_char, pad_length, pad_right) 
{
   var result = this;
   if( (typeof pad_char === 'string') && (pad_char.length === 1) && (pad_length > this.length) )
   {
      var padding = new Array(pad_length - this.length + 1).join(pad_char); //thanks to http://stackoverflow.com/questions/202605/repeat-string-javascript/2433358#2433358
      result = (pad_right ? result + padding : padding + result);
   }
   return result;
}

그리고 당신은 할 수 있습니다 :

alert( "3".pad("0", 3) ); //shows "003"
alert( "hi".pad(" ", 3) ); //shows " hi"
alert( "hi".pad(" ", 3, true) ); //shows "hi "

프로토 타입을 엉망으로 만들지 마십시오!
Rihards

1

아주 간단한 해키 한 줄짜리 라이너를 패딩하려면 원하는 최대 패딩 길이의 원하는 패딩 문자 문자열을 만들고 패딩하려는 길이만큼 하위 문자열을 지정하십시오.

예 : 문자열 저장소 e를 25 ~ 25 자 사이의 공백으로 채 웁니다.

var e = "hello"; e = e + "                         ".substring(e.length)

결과: "hello "

입력 한 번호로 동일한 작업을 수행하려면 .toString()이전에 전화 하십시오.


이것은 실제로 범용 함수가 아니라 매우 깔끔합니다.하지만 루프를 저장하기 위해이를 일부 상황에서 유효한 핵으로 볼 수 있습니다.
ankr

재미있는 생각. @ankr 범용 함수 Array(n).join(c)로 사용하려면 패딩 길이와 패딩 문자를 구성 할 수 있습니다 ( 예 :) Array(26).join(' ').
WynandB

1

또 다른 몇 가지 솔루션의 조합으로 받아

/**
 * pad string on left
 * @param {number} number of digits to pad, default is 2
 * @param {string} string to use for padding, default is '0' *
 * @returns {string} padded string
 */
String.prototype.paddingLeft = function (b,c) {
    if (this.length > (b||2))
        return this+'';
  return (this||c||0)+'',b=new Array((++b||3)-this.length).join(c||0),b+this
};

/**
 * pad string on right
 * @param {number} number of digits to pad, default is 2
 * @param {string} string to use for padding, default is '0' *
 * @returns {string} padded string
 */
String.prototype.paddingRight = function (b,c) {
  if (this.length > (b||2))
        return this+'';
  return (this||c||0)+'',b=new Array((++b||3)-this.length).join(c||0),this+b
};    

1

한 친구가 JavaScript 함수를 사용하여 왼쪽을 채우는 것에 대해 물었습니다. 그것은 골프를 코딩하기 위해 채팅에서 우리 중 일부 사이에서 약간의 노력으로 바뀌 었습니다. 결과는 다음과 같습니다.

function l(p,t,v){
    v+="";return v.length>=t?v:l(p,t,p+v); 
}

채워질 값이 문자열인지 확인한 다음 원하는 총 길이의 길이가 아닌 경우 한 번 채워진 다음 재귀합니다. 좀 더 논리적으로 명명하고 구조적으로 보이는 모습은 다음과 같습니다.

function padLeft(pad, totalLength, value){
    value = value.toString();

    if( value.length >= totalLength ){
        return value;
    }else{
        return padLeft(pad, totalLength, pad + value);
    }
}

우리가 사용한 예제는 0최대 길이 6을 만들기 위해 숫자가 왼쪽에 채워지 도록하는 것입니다. 예제 세트는 다음과 같습니다.

function l(p,t,v){v+="";return v.length>=t?v:l(p,t,p+v);}

var vals = [6451,123,466750];

var pad = l(0,6,vals[0]);// pad with 0's, max length 6

var pads = vals.map(function(i){ return l(0,6,i) });

document.write(pads.join("<br />"));


1

조금 늦었지만 어쨌든 공유 할 수 있다고 생각했습니다. Object에 프로토 타입 확장을 추가하는 것이 유용하다는 것을 알았습니다. 그렇게하면 왼쪽이나 오른쪽으로 숫자와 문자열을 채울 수 있습니다. 스크립트에 비슷한 유틸리티가 포함 된 모듈이 있습니다.

// include the module in your script, there is no need to export
var jsAddOns = require('<path to module>/jsAddOns');

~~~~~~~~~~~~ jsAddOns.js ~~~~~~~~~~~~~

/* 
 * method prototype for any Object to pad it's toString()
 * representation with additional characters to the specified length
 *
 * @param padToLength required int
 *     entire length of padded string (original + padding)
 * @param padChar optional char
 *     character to use for padding, default is white space
 * @param padLeft optional boolean
 *     if true padding added to left
 *     if omitted or false, padding added to right
 *
 * @return padded string or
 *     original string if length is >= padToLength
 */
Object.prototype.pad = function(padToLength, padChar, padLeft) {    

    // get the string value
    s = this.toString()

    // default padToLength to 0
    // if omitted, original string is returned
    padToLength = padToLength || 0;

    // default padChar to empty space
    padChar = padChar || ' ';


    // ignore padding if string too long
    if (s.length >= padToLength) {
        return s;
    }

    // create the pad of appropriate length
    var pad = Array(padToLength - s.length).join(padChar);

    // add pad to right or left side
    if (padLeft) {
        return pad  + s;        
    } else {
        return s + pad;
    }
};

1
  1. str = pad + str;데이터가 매번 재 할당되므로 데이터를 어딘가에 (특히 처음에는 시작하지 않는) 삽입하지 마십시오 . 항상 끝에 추가하십시오!
  2. 고리에 끈을 채우지 마십시오. 그대로두고 패드 끈을 먼저 만드십시오. 결국 메인 문자열과 연결하십시오.
  3. 매번 패딩 문자열을 할당하지 마십시오 (예 :) str += pad;. 패딩 문자열을 자체에 추가하고 첫 번째 x 문자를 추출하는 것이 훨씬 빠릅니다 (첫 번째 문자에서 추출하면 구문 분석기가이를 효율적으로 수행 할 수 있음). 이것은 기하 급수적으로 증가하므로 일시적으로 일부 메모리를 낭비합니다 (매우 큰 텍스트로이 작업을 수행해서는 안 됨).

if (!String.prototype.lpad) {
    String.prototype.lpad = function(pad, len) {
        while (pad.length < len) {
            pad += pad;
        }
        return pad.substr(0, len-this.length) + this;
    }
}

if (!String.prototype.rpad) {
    String.prototype.rpad = function(pad, len) {
        while (pad.length < len) {
            pad += pad;
        }
        return this + pad.substr(0, len-this.length);
    }
}


0

여기 내 테이크가있다

성능이 확실하지 않지만 여기에서 본 다른 옵션보다 훨씬 읽기 쉽습니다.

var replicate = function(len, char) {
  return Array(len+1).join(char || ' ');
};

var padr = function(text, len, char) {
  if (text.length >= len) return text;
  return text + replicate(len-text.length, char);
};
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.