Có một hàm JavaScript nào có thể đệm một chuỗi để có được độ dài xác định không?


272

Tôi đang cần một hàm JavaScript có thể lấy một giá trị và đệm nó theo một độ dài nhất định (tôi cần khoảng trắng, nhưng mọi thứ sẽ làm được). Tôi đã tìm thấy cái này:

Mã số:

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

Thí dụ:

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

Nhưng tôi không biết nó đang làm cái quái gì và nó dường như không hiệu quả với tôi.


Câu trả lời:


515

Tôi tìm thấy giải pháp này ở đây và điều này đối với tôi đơn giản hơn nhiều:

var n = 123

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

Và ở đây tôi đã thực hiện một phần mở rộng cho đối tượng chuỗi:

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

Một ví dụ để sử dụng nó:

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

Điều này sẽ trả về một thời gian ở định dạng "15:30"


11
Dễ dàng tiếp cận dễ đọc và ngắn gọn nhất mà tôi đã tìm thấy; đủ đơn giản để tôi thường không bận tâm đến tiện ích mở rộng nguyên mẫu (ít nhất là chỉ cho một vài lần sử dụng trong một ứng dụng). Làm tốt.
brichin

32
Xin lưu ý, giải pháp này sẽ rút ngắn các chuỗi dài hơn đối số lát (tức là 5 ký tự ở đây).
Denis V

1
Xin chào Yaniv. Bạn có một đề nghị rất tốt để sửa đổi thuật toán. Tuy nhiên, trong trường hợp của tôi, các yêu cầu luôn đi trước vấn đề này bởi vì khi tôi cố gắng định dạng một cái gì đó, tôi luôn có tối thiểu các thông số kỹ thuật về giá trị mà tôi phải xử lý và trong trường hợp này, các thông số kỹ thuật sẽ khắc phục vấn đề này. Ví dụ: nếu tôi có số điện thoại để định dạng và tôi chỉ xử lý điện thoại ở Canada, tôi sẽ xác thực rằng số điện thoại có 10 ký tự trước khi định dạng. Trong mọi trường hợp, giải pháp của bạn là tuyệt vời quá. :)
Samuel

1
Nếu bạn đang làm điều này rất nhiều (ví dụ: đệm một danh sách dài các giá trị trong danh sách sắp xếp nào đó trên trang của bạn hoặc ứng dụng khác) cũng sẽ thấy câu trả lời với phương pháp nhanh hơn tại stackoverflow.com/questions/2686855/
trộm

6
Điều này rất cần được cập nhật để sử dụng các String lib lib String.padStart()String.padEnd()cho phần đệm trái / phải.
SudoKid

119

Một phương pháp nhanh hơn

Nếu bạn đang thực hiện việc này nhiều lần, ví dụ để đệm các giá trị trong một mảng và hiệu suất là một yếu tố, cách tiếp cận sau đây có thể mang lại cho bạn lợi thế gần gấp 100 lần về tốc độ ( jsPerf ) so với giải pháp khác hiện đang thảo luận trên các trang web liên mạng. Ý tưởng cơ bản là bạn đang cung cấp chức năng pad với một chuỗi rỗng được đệm đầy đủ để sử dụng làm bộ đệm. Hàm pad chỉ nối thêm chuỗi được thêm vào chuỗi được đệm trước này (nối một chuỗi) và sau đó cắt hoặc cắt kết quả theo độ dài mong muốn.

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

Ví dụ: để zero pad một số có độ dài 10 chữ số,

pad('0000000000',123,true);

Để đệm một chuỗi có khoảng trắng, vì vậy toàn bộ chuỗi là 255 ký tự,

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

Kiểm tra hiệu suất

Xem thử nghiệm jsPerf tại đây .

Và điều này cũng nhanh hơn ES6 gấp string.repeat2 lần, như được hiển thị bởi JsPerf đã sửa đổi ở đây


5
+1 Một phần của vấn đề của tôi với StackOverflow là việc người điều hành không thể thay đổi phiếu bầu dựa trên các câu trả lời rõ ràng là vượt trội. Đây là một trong những trường hợp đó.
Jason Sebring

1
Như một người khác đã chứng minh trong một jsPerf sau này (các liên kết được thêm ở trên), cách tiếp cận này nhanh hơn ~ 2 lần so với string.repeatphương pháp ES6 . Vì vậy, nếu bạn đang làm rất nhiều chuỗi đệm, chắc chắn thử điều này.
Shyam Habarakada

5
Tôi bối rối trước nhận xét của Jason - câu trả lời này khác với câu trả lời như thế nào?
corwin.amber

1
Tôi nhìn vào jsPerf của bạn. Các bài kiểm tra này dành cho chức năng của bạn và một cái gì đó sử dụng vòng lặp while () mà không có câu trả lời được đánh giá cao nào khác sử dụng. Tôi không chắc điều đó có nghĩa là nó nhanh hơn?
Hold OfferHunger

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;

}

Nó dễ đọc hơn nhiều.


1
Có vẻ như không hoạt động khi pad là một khoảng pad("hello", 20) = "hello "
trắng

40

Đây là một cách tiếp cận đệ quy cho nó.

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

Một ví dụ...

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

7
cũng có một định nghĩa đệ quy về phép nhân số nguyên ... luôn luôn nhớ có một "lời nguyền" trong đệ quy ...
dòng chảy

32
Ngoài ra còn có narwhals và một anh chàng say rượu trên đường, nhưng không liên quan. Lời nguyền đệ quy chỉ áp dụng khi lập trình viên không biết khi nào thì phù hợp.
hypno7oad

12
"Lời nguyền đệ quy chỉ áp dụng khi lập trình viên không biết khi nào thì phù hợp" Hoặc khi họ không nhận ra điều đó là không phù hợp. Chẳng hạn như cho một chức năng pad chuỗi đơn giản.
Danation

Điều này là khá thanh lịch và làm việc hoàn hảo cho trường hợp sử dụng của tôi. Nếu bạn cần đệm khoảng trắng để căn chỉnh văn bản, chỉ cần ném theo chiều dài của chuỗi dài nhất =)
Damon Aw

12
Nó là thanh lịch, nhưng nó cũng tạo ra một chuỗi mới trên mỗi lần lặp của hàm. Hàm này là O (n) trong khi giải pháp phổ biến nhất của @Samuel là O (1). Cả hai đều thanh lịch, nhưng một là hiệu quả hơn nhiều. Điều đó nói rằng, đó là một cách tiếp cận gọn gàng, và có thể còn nhanh hơn trong một ngôn ngữ khác.
nghiền nát

40

String.prototype.padStart()String.prototype.padEnd()hiện đang là đề xuất cho ứng viên TC39: xem github.com/tc39/proposed-opes-pad-start-end (chỉ có sẵn trong Firefox kể từ tháng 4 năm 2016; có sẵn một polyfill ).


13
Được hỗ trợ bởi tất cả các trình duyệt (hiện đại) ngay bây giờ: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/
Kẻ

Dành cho người lười biếng: myString.padStart(padLength [, padString])myString.padEnd(padLength [, padString])
Johan Dettmar

1
Vui lòng thêm một số ví dụ sử dụng, bây giờ điều này đã được hỗ trợ bởi tất cả các trình duyệt hiện đại. Điều này nên được khuyến khích.
Franklin Yu

Chúa ơi, làm thế nào mà tôi không nghe thấy điều này cho đến hôm nay ?? Đây phải là câu trả lời được chấp nhận.
bầu chọn

29

ECMAScript 2017 thêm phương thức padStart vào nguyên mẫu String. Phương pháp này sẽ đệm một chuỗi có khoảng trắng đến một độ dài nhất định. Phương pháp này cũng lấy một chuỗi tùy chọn sẽ được sử dụng thay vì khoảng trắng để đệm.

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

Một phương thức padEnd cũng được thêm vào hoạt động theo cách tương tự.

Để biết tính tương thích của trình duyệt (và một polyfill hữu ích) hãy xem liên kết này .


Câu trả lời tốt nhất TẠI ĐÂY cho ngày hôm nay! 2019!
Peter Krauss

22

Sử dụng lặp lại phương thức ECMAScript 6 String # , một hàm pad đơn giản như:

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

String#repeathiện chỉ được hỗ trợ trong Firefox và Chrome. để thực hiện khác, người ta có thể xem xét các polyfill đơn giản sau:

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

Đối với những người làm việc trong Node.js, String.repeat cũng được hỗ trợ ở đó.
jkt123

15

Sử dụng các hàm String # repeatArrow của phương thức ECMAScript 6 , một hàm pad đơn giản như sau:

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

jsfiddle

chỉnh sửa: đề xuất từ ​​các ý kiến:

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

bằng cách này, nó sẽ không gây ra lỗi khi s.lengthlớn hơnn

chỉnh sửa2: đề xuất từ ​​các ý kiến:

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

bằng cách này, bạn có thể sử dụng hàm cho các chuỗi và các chuỗi không giống nhau.


1
Điều này là tốt đẹp, nhưng nếu s.lengthlớn hơn nnó sẽ ném. Gợi ý:let leftPad = (s, c, n) => n - s.length > 0 ? c.repeat(n - s.length) + s : s;
David G

nó không hoạt động cho các chuỗi không. Như trong leftPad(12, ' ', 5). Mặc dù tôi biết nghiêm túc rằng có thể ổn, nhưng đây có lẽ là một trong những trường hợp sử dụng phổ biến nhất (số đệm). Có lẽ function leftPad(s, c, n) { s = s.toString(); return s.length > len ? s : c.repeat(n - s.length) + s; }. Sử dụng functionphương tiện leftPad có thể ở dưới cùng của tệp. Nếu không, bạn nên sử dụng constkhông phải varcũng không let.
gman

@gman cảm ơn vì lời đề nghị này, nhưng biến của bạn là lengì?
InsOp

Doh, lennên làn
gman

14

Thủ thuật chính trong cả hai giải pháp đó là tạo một arraythể hiện với kích thước nhất định (nhiều hơn một độ dài mong muốn), và sau đó gọi ngay join()phương thức để tạo một string. Các join()phương pháp được thông qua lớp đệm string(số lượng có lẽ). Vì arraytrống rỗng, các ô trống sẽ được hiển thị là trống stringstrong quá trình tham gia arrayvào một kết quả stringvà chỉ phần đệm sẽ vẫn còn. Đó là một kỹ thuật thực sự tốt đẹp.


10

pad với các giá trị mặc định

Tôi nhận thấy rằng tôi chủ yếu cần padLeft để chuyển đổi thời gian / đệm số

vì vậy tôi đã viết chức năng này

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

Hàm đơn giản này hỗ trợ Số hoặc Chuỗi làm đầu vào

pad mặc định là 2 ký tự

char mặc định là 0

vì vậy tôi chỉ có thể viết

padL(1);
// 01

nếu tôi thêm đối số thứ hai (chiều rộng pad)

padL(1,3);
// 001

tham số thứ ba (pad char)

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

EDIT @BananaAcid nếu bạn chuyển một giá trị không xác định hoặc chuỗi có độ dài 0 bạn nhận được 0undefined..so:

như đề xuất

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

nhưng điều này cũng có thể đạt được một cách ngắn gọn hơn.

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

cũng hoạt động với:

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

Và nếu bạn muốn có thể đệm theo cả hai cách:

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

có thể được viết theo cách ngắn hơn mà không cần sử dụng lát.

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 
)

*/

bây giờ nếu bạn cố gắng 'averylongword' với 2 ... đó không phải là vấn đề của tôi.


Nói rằng tôi cho bạn một lời khuyên.

Hầu hết thời gian nếu bạn đệm bạn làm điều đó cho cùng một giá trị N lần.

Sử dụng bất kỳ loại chức năng nào trong một vòng lặp làm chậm vòng lặp !!!

Vì vậy, nếu bạn chỉ muốn để lại một số con số trong một danh sách dài, đừng sử dụng các hàm để làm điều đơn giản này.

sử dụng một cái gì đó như thế này:

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

nếu bạn không biết kích thước đệm tối đa dựa trên các số bên trong mảng.

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"
*/

Rất đẹp! Đã đưa ra cùng một kết quả, giống như một ghi chú: điều này sẽ kết hợp chuỗi với độ dài tối đa đã cho và một chuỗi trống sẽ là một char quá ngắn và str không xác định sẽ dẫn đến việc sử dụng ong 'không xác định' cũng như mối nối có thể gây ra lỗi - kết hợp. return (new Array((b||1)+1).join(c||0)+(a||'')).slice(-(b||2)). Và như mọi khi: các bạn ngoài kia, đừng chỉ sao chép mã mà bạn không hiểu.
BananaAcid

1
(mảng mới (b || 2) .join (c || 0) + (một || c || 0)) lát (-b) ... ngắn hơn.
cocco


9

Lấy ý tưởng của Samuel, hướng lên đây. Và hãy nhớ một tập lệnh SQL cũ, tôi đã thử với điều này:

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

Nó hoạt động trong tất cả các trường hợp tôi có thể tưởng tượng:

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

chuỗi đệm đã được thực hiện trong phiên bản javascript mới.

str.padStart(targetLength [, padString])

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

Nếu bạn muốn chức năng của riêng bạn kiểm tra ví dụ này:

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

Câu trả lời này đã được đề cập bởi nhiều câu trả lời khác vì vậy đây là một bản sao không thêm thông tin mới. Hãy tìm kiếm trước khi trả lời.
Franklin Yu

Đây là cái đầu tiên có chữ ký đầy đủ. Và nó phải là câu trả lời duy nhất cho đến ngày hôm nay.
d_f

4

Đây là một chức năng đơn giản mà tôi sử dụng.

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

Ví dụ:

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

4

Một cách ngắn gọn:

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

Thí dụ:

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

trả lại: "001234"


1
có lẽ String.prototype.padStart()nên dễ dàng hơn
Max Peng

3

es7 chỉ là bản nháp và đề xuất ngay bây giờ, nhưng nếu bạn muốn theo dõi khả năng tương thích với thông số kỹ thuật, các chức năng pad của bạn cần:

  1. Hỗ trợ pad đa ký tự.
  2. Không cắt ngắn chuỗi đầu vào
  3. Pad mặc định vào không gian

Từ thư viện polyfill của tôi, nhưng áp dụng sự chuyên cần của riêng bạn cho các phần mở rộng nguyên mẫu.

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

Đây là một câu trả lời đơn giản về cơ bản một dòng mã.

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

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

Đảm bảo số lượng ký tự trong phần đệm của bạn, số không ở đây, ít nhất bằng số lượng độ dài tối thiểu dự định của bạn. Vì vậy, thực sự, để đặt nó vào một dòng, để có kết quả là "00035" trong trường hợp này là:

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

2

Thao tác mảng thực sự chậm so với concat chuỗi đơn giản. Tất nhiên, điểm chuẩn cho trường hợp sử dụng của bạn.

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

Một biến thể của câu trả lời của @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;
};

Ví dụ:

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

2

Đó là năm 2014 và tôi đề xuất chức năng đệm chuỗi Javascript. Hà!

Bare-bone: pad phải với không gian

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

Fancy: pad với các tùy chọn

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

Cách sử dụng (ưa thích):

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

Tôi nghĩ tốt hơn để tránh đệ quy vì nó tốn kém.

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

Đây là một hàm JavaScript có thêm số lượng phần đệm được chỉ định với tính năng tùy chỉnh. hàm có ba tham số.

    padMe -> chuỗi hoặc số sang pad bên trái
    miếng đệm -> số lượng miếng đệm
    padSymble -> symble tùy chỉnh, mặc định là "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());
    }
/ * Đây là một số kết quả:

> bên trái (1)
"1"
> bên trái (1, 4)
"0001"
> bên trái (1, 4, "0")
"0001"
> bên trái (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;
}

Và sau đó bạn có thể làm:

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

Đừng lộn xộn với các nguyên mẫu!
Rihards 19/12/13

1

Nếu bạn chỉ muốn một miếng lót đơn giản rất đơn giản để đệm, chỉ cần tạo một chuỗi ký tự đệm mong muốn có độ dài đệm tối đa mong muốn và sau đó xâu chuỗi nó theo chiều dài của miếng đệm bạn muốn.

Ví dụ: đệm chuỗi lưu trữ trong ekhoảng trắng đến 25 ký tự.

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

Kết quả: "hello "

Nếu bạn muốn làm tương tự với một số như đầu vào, chỉ cần gọi .toString()vào số đó trước.


Điều này thực sự khá gọn gàng, không phải là một chức năng mục đích chung - nhưng tôi có thể thấy đây là một hack hợp lệ trong một số bối cảnh để lưu một vòng lặp.
ankr

Ý tưởng thú vị. @ankr Để sử dụng nó như là một chức năng mục đích chung, bạn có thể sử dụng Array(n).join(c)để làm cho chiều dài đệm và vật đệm cấu hình, ví dụ Array(26).join(' ').
WynandB

1

còn một cách khác với sự kết hợp của một vài giải pháp

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

Một người bạn đã hỏi về việc sử dụng hàm JavaScript để chuyển sang trái. Nó đã biến thành một chút nỗ lực giữa một số người trong chúng ta trong trò chuyện để viết mã golf. Đây là kết quả:

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

Nó đảm bảo rằng giá trị được đệm là một chuỗi, và sau đó nếu nó không phải là độ dài của tổng chiều dài mong muốn, nó sẽ đệm nó một lần và sau đó lặp lại. Đây là những gì nó trông giống với cách đặt tên và cấu trúc hợp lý hơn

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

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

Ví dụ chúng tôi đang sử dụng là để đảm bảo rằng các số được đệm 0ở bên trái để tạo độ dài tối đa là 6. Dưới đây là một ví dụ được đặt:

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

Hơi muộn một chút, nhưng dù sao tôi cũng có thể chia sẻ. Tôi thấy nó hữu ích khi thêm một phần mở rộng nguyên mẫu vào Object. Bằng cách đó tôi có thể đệm số và chuỗi, trái hoặc phải. Tôi có một mô-đun với các tiện ích tương tự tôi bao gồm trong các kịch bản của tôi.

// 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. Không bao giờ chèn dữ liệu ở đâu đó (đặc biệt là không bắt đầu, như str = pad + str;), vì dữ liệu sẽ được phân bổ lại mọi lúc. Nối luôn luôn ở cuối!
  2. Đừng đệm chuỗi của bạn trong vòng lặp. Để nó một mình và xây dựng chuỗi pad của bạn đầu tiên. Cuối cùng, nối nó với chuỗi chính của bạn.
  3. Đừng gán chuỗi đệm mỗi lần (như str += pad;). Sẽ nhanh hơn nhiều khi nối chuỗi đệm vào chính nó và trích xuất các ký tự x đầu tiên (trình phân tích cú pháp có thể thực hiện việc này một cách hiệu quả nếu bạn trích xuất từ ​​char đầu tiên). Đây là sự tăng trưởng theo cấp số nhân, có nghĩa là nó tạm thời lãng phí một số bộ nhớ (bạn không nên làm điều này với các văn bản cực kỳ lớn).

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

Đây là của tôi

Tôi không chắc lắm về hiệu suất của nó, nhưng tôi thấy nó dễ đọc hơn nhiều so với các tùy chọn khác mà tôi thấy quanh đây ...

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);
};
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.