정해진 길이에 도달하기 위해 문자열을 패딩할 수 있는 JavaScript 함수가 있나요?
값을 취득하여 지정된 길이로 패딩할 수 있는 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;
};
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)
);EcmaScript 2017은 이러한 목적으로 (와 함께) 추가되었습니다.
"Jonas".padStart(10); // Default pad string is a space
"42".padStart(6, "0"); // Pad with "0"
"*".padStart(8, "-/|\\"); // produces '-/|\\-/|*'
하지 않는 , JS는 「」를 해 주세요.String.padStart폴리필로 추가할 수 있습니다.
ES-2017 이전
여기서 이 솔루션을 발견했는데, 이 솔루션은 훨씬 더 간단합니다.
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" 형식의 시간이 반환됩니다.
보다 빠른 방법
예를 들어 어레이의 값을 패딩하는 등 반복적인 경우, 퍼포먼스가 중요한 다음 접근방식을 사용하면 현재 인터웹에서 논의되고 있는 다른 솔루션보다 속도(jsPerf)가 100배 가까이 향상될 수 있습니다.기본 개념은 패드 기능에 버퍼로 사용할 빈 문자열을 완전히 패딩하여 제공하는 것입니다.패드 기능은 이 사전 패딩된 문자열에 추가할 문자열(콘센트 문자열 1개)에 추가한 후 원하는 길이로 결과를 슬라이스 또는 트리밍합니다.
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자리 길이로 제로 패드로 하려면
pad('0000000000',123,true);
문자열을 공백으로 채우려면 문자열 전체가 255자여야 합니다.
var padding = Array(256).join(' '), // make a string of 255 spaces
pad(padding,123,true);
퍼포먼스 테스트
여기서 jsPerf 테스트를 참조하십시오.
이것은 ES6보다 .string.repeat여기 개정된 JsPerf에서 알 수 있듯이, 2배까지 감소합니다.
해 주세요.jsPerf가 아닙니다.
우리가 원래 다양한 방법을 벤치마킹하기 위해 사용했던 jsPerf 사이트는 더 이상 온라인 상태가 아닙니다.유감스럽게도 그 테스트 결과를 얻을 수 없습니다.슬프지만 사실이다.
String.prototype.padStart() ★★★★★★★★★★★★★★★★★」String.prototype.padEnd()님은 현재 TC39 후보 제안서입니다.github.com/tc39/proposal-string-pad-start-end (2016년 4월 현재 Firefox에서만 이용 가능하며 폴리필도 이용 가능).
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;
}
훨씬 더 읽기 쉬워요.
여기 재귀적 접근법이 있습니다.
function pad(width, string, padding) {
return (width <= string.length) ? string : pad(width, padding + string, padding)
}
예를 들면...
pad(5, 'hi', '0')
=> "000hi"
ECMAScript 2017은 string 프로토타입에 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 메서드도 추가되었습니다.
브라우저 호환성(및 유용한 폴리필)에 대해서는 이 링크를 참조하십시오.
ECMAScript 6 메서드 String #repeat을 사용하면 패드 기능은 다음과 같이 간단합니다.
String.prototype.padLeft = function(char, length) {
return char.repeat(Math.max(0, length - this.length)) + this;
}
String#repeat「 Firefox 」 에 「 Chrome 」 implement implement implement implement 。과 같은 폴리필을 할 수 .기타 구현의 경우 다음과 같은 단순한 폴리필을 고려할 수 있습니다.
String.prototype.repeat = String.prototype.repeat || function(n){
return n<=1 ? this : (this + this.repeat(n-1));
}
ECMAScript 6 메서드 String #repeat 및 Arrow 함수를 사용하면 패드 기능은 다음과 같이 간단합니다.
var leftPad = (s, c, n) => c.repeat(n - s.length) + s;
leftPad("foo", "0", 5); //returns "00foo"
edit: 코멘트로부터의 제안:
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; }
이렇게 해서 현악기, 비현악기, 비현악기, 같은 기능을 사용할 수 있습니다.
두 모두 은 이 an an an an an an an an an an an an an an an an an an an 를 만드는 것입니다.array의(instance)를 합니다.join()string . 。join()합니다.string(서양속담, 돈속담) ★★★★★★★★★★★★★★★★★.array셀이 비어 있으면 빈 빈 셀로 .strings array의 결과로string딩만남남 남남남다다정말 좋은 기술이에요.
ES8에서는 패딩에 2가지 옵션이 있습니다.
매뉴얼에서 확인할 수 있습니다.
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padEnd
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart
기본값 패드
시간 변환/숫자 패딩을 위해 pad Left가 가장 필요하다는 것을 알았습니다.
그래서 나는 이 함수를 썼다.
function padL(a,b,c){//string/number,length=2,char=0
return (new Array(b||2).join(c||0)+a).slice(-b)
}
이 간단한 함수는 숫자 또는 문자열을 입력으로 지원합니다.
기본 패드는 2글자입니다.
기본 char는 0입니다.
그래서 나는 간단하게 쓸 수 있다.
padL(1);
// 01
두 번째 인수(패드 폭)를 추가하면
padL(1,3);
// 001
세 번째 파라미터(패드 문자)
padL('zzz',10,'x');
// xxxxxxxzzz
정의되지 않은 값 또는 0 길이의 문자열을 전달하면 EDIT @BananaAcid0undefined 래래:
제안대로
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로 '긴 단어'를 패딩하려고 한다면... 그건 내 문제가 아니야.
내가 팁을 준다고 했어.
대부분의 경우 패딩을 하면 동일한 값 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"
*/
사무엘의 아이디어를 받아들이죠, 여기 위쪽으로요.이전 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
패딩 문자열이 새로운 Javascript 버전에 추가되었습니다.
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
다음은 사용할 수 있는 빌트인 방법입니다.
str1.padStart(2, '0')
여기 제가 사용하는 간단한 기능이 있습니다.
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
지름길:
(x=>(new Array(int-x.length+1)).join(char)+x)(String)
예:
(x=>(new Array(6-x.length+1)).join("0")+x)("1234")
반품: "001234"
es7은 현재 초안이나 제안서일 뿐이지만 사양과의 호환성을 추적하려면 패드 기능이 다음과 같이 필요합니다.
- 다중 문자 패드 지원.
- 입력 문자열을 잘라내지 않음
- 패드는 기본적으로 공백입니다.
내 폴리필 라이브러리에서 시제품 확장에 대한 자체 실사를 적용하십시오.
// 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 );
});
이것은 기본적으로 한 줄의 코드로 이루어진 간단한 대답입니다.
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);
단순한 문자열 콘카트에 비해 어레이 조작이 매우 느립니다.물론, 사용 사례에 대한 벤치마크입니다.
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;
};
@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'
2014년, 자바스크립트 스트링 패딩 기능을 추천합니다.하!
베어본: 우측 패드 (스페이스 포함)
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"
유틸리티 라이브러리를 포함해도 괜찮다면 Lodash 라이브러리에는 _.pad, _.padLeft 및 _.padRight 기능이 있습니다.
비용이 많이 들기 때문에 재귀는 피하는 것이 좋다고 생각합니다.
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));는 세합니다.이치노
padMe --> 왼쪽 패드의 문자열 또는 숫자패드 --> 패드 수padSymble --> 커스텀 심볼, 기본값은 "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"> 왼쪽 패드 (1, 4, "@")"@@@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 "
심플한 원라이너 패딩을 원하는 경우 원하는 최대 패딩 길이의 패딩 문자를 스트링으로 만들어 패딩하고 싶은 길이로 서브스트링하면 됩니다.
예: 스트링 스토어 채우기e공백은 25자까지입니다.
var e = "hello"; e = e + " ".substring(e.length)
결과:"hello "
입력된 번호로 동일한 작업을 수행하려면 전화만 하십시오..toString()그 전에 써놨어요.
몇 가지 솔루션을 조합한 또 다른 시도
/**
* 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
};
친구가 자바스크립트 기능을 사용하여 왼쪽 패드를 채우는 것에 대해 물었다.우리 중 몇몇은 골프 코드화를 위해 채팅으로 약간의 노력을 기울였다.결과는 다음과 같습니다.
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 />"));조금 늦었지만 어쨌든 나눠먹어야겠다고 생각했어요.오브젝트에 프로토타입 확장자를 추가하는 것이 도움이 되었습니다.그래야 왼쪽이든 오른쪽이든 숫자와 문자열을 넣을 수 있어스크립트에 포함된 것과 유사한 유틸리티를 사용하는 모듈이 있습니다.
// 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;
}
};
- 데이터를 다른 곳에 삽입하지 마십시오(특히 처음부터 삽입하지 마십시오).
str = pad + str;데이터가 매번 재할당되기 때문입니다.항상 마지막에 추가! - 끈을 고리에 채우지 마라.그냥 놔두고 먼저 패드 끈을 만들어.결국 당신의 메인 스트링과 연결합니다.
- 매번 패딩 문자열을 할당하지 않음(예:
str += pad;패딩 문자열을 그 자체에 부가하여 첫 번째 x-chars를 추출하는 것이 훨씬 빠릅니다(파서는 첫 번째 문자에서 추출하면 효율적으로 이 작업을 수행할 수 있습니다).이것은 기하급수적인 증가입니다.즉, 일시적으로 메모리가 낭비됩니다(매우 큰 텍스트에서는 이 작업을 수행하지 마십시오).
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);
}
}언급URL : https://stackoverflow.com/questions/2686855/is-there-a-javascript-function-that-can-pad-a-string-to-get-to-a-determined-leng
'programing' 카테고리의 다른 글
| timedelta를 총 초수로 변환 (0) | 2023.02.06 |
|---|---|
| 팬더 DataFrame에서 열의 값이 최대인 행을 찾습니다. (0) | 2023.02.06 |
| MySQL 발생 횟수가 2를 초과합니다. (0) | 2023.02.06 |
| PDO:: 10진수 타입의 PARAM? (0) | 2023.02.06 |
| **kwargs 인수를 **kwargs를 사용하여 다른 함수에 전달합니다. (0) | 2023.02.06 |