क्या कोई जावास्क्रिप्ट फ़ंक्शन है जो निर्धारित लंबाई तक पहुंचने के लिए एक स्ट्रिंग को पैड कर सकता है?


272

मुझे एक जावास्क्रिप्ट फंक्शन की जरूरत है, जो एक वैल्यू ले सके और उसे दी गई लंबाई तक पैड कर सके (मुझे स्पेस चाहिए, लेकिन कुछ भी करना होगा)। मुझे मिला:

कोड:

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>

लेकिन मुझे नहीं पता कि यह क्या कर रहा है और यह मेरे लिए काम नहीं करता है।


8
"जोनास" .padStart (7, "") डेवलपर.
Aus

जवाबों:


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
आसानी से सबसे पठनीय और संक्षिप्त दृष्टिकोण मैंने पाया है; काफी सरल है कि मैं आम तौर पर प्रोटोटाइप एक्सटेंशन (कम से कम एक ऐप में केवल कुछ उपयोगों के लिए) से परेशान नहीं होता। बहुत बढ़िया।
ब्रिचिन

32
ज्ञात हो, यह समाधान उन स्ट्रिंग्स को छोटा कर देगा जो स्लाइस तर्क (यानी यहां 5 वर्ण) से अधिक लंबे हैं।
डेनिस V

1
हाय यानिव। एल्गोरिथ्म को संशोधित करने के लिए आपके पास एक बहुत अच्छा सुझाव है। हालाँकि, मेरे मामले में, आवश्यकताएँ हमेशा इस समस्या से पहले होती हैं क्योंकि जब मैं कुछ प्रारूपित करने की कोशिश करता हूं, तो मेरे पास हमेशा उस मूल्य के बारे में न्यूनतम विनिर्देश होते हैं जिनका मुझे इलाज करना होता है और इस मामले में, विनिर्देश इस समस्या को ठीक कर देंगे। उदाहरण के लिए, यदि मेरे पास प्रारूप करने के लिए एक फ़ोन नंबर है और मैं केवल कनाडा में फ़ोन को संभालता हूँ, तो मैं यह सत्यापित करूँगा कि फ़ोन नंबर को प्रारूपित करने से पहले 10 वर्ण हैं। किसी भी मामले में, आपका समाधान भी बहुत अच्छा है। :)
शमूएल

1
यदि आप इसे बहुत कुछ कर रहे हैं (जैसे आपके पृष्ठ या अन्य एप्लिकेशन पर किसी प्रकार की सूची में मानों की एक लंबी सूची
पाडिंग कर रहे हैं) तो

6
जेएस के String कामों का उपयोग करने String.padStart()और String.padEnd()बाएं / दाएं पैडिंग के लिए इसे बुरी तरह से अपडेट करने की आवश्यकता है ।
सुदोकिड

119

एक तेज विधि

यदि आप बार-बार ऐसा कर रहे हैं, उदाहरण के लिए किसी सरणी में पैड मानों के लिए, और प्रदर्शन एक कारक है, तो निम्नलिखित दृष्टिकोण आपको अन्य समाधानों में गति ( jsPerf ) में लगभग 100x लाभ दे सकता है जो वर्तमान में अंतर जाले पर चर्चा कर रहे हैं। मूल विचार यह है कि आप पैड फ़ंक्शन को बफर के रूप में उपयोग करने के लिए पूरी तरह से गद्देदार खाली स्ट्रिंग प्रदान कर रहे हैं। पैड फ़ंक्शन केवल स्ट्रिंग को इस पूर्व-गद्देदार स्ट्रिंग (एक स्ट्रिंग कॉनैट) में जोड़ने की अपील करता है और फिर वांछित लंबाई तक परिणाम को स्लाइस या ट्रिम करता है।

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 परीक्षण यहाँ देखें ।

और यह string.repeatईएस 6 की तुलना में 2 गुना तेज है , साथ ही यहां संशोधित जेस्पेरफ द्वारा दिखाया गया है


5
+1 StackOverflow के साथ मेरे मुद्दे का हिस्सा स्पष्ट रूप से बेहतर हैं कि उत्तरों के आधार पर वोट बदलने के लिए मध्यस्थों के लिए अक्षमता है। यह उन मामलों में से एक है।
जेसन सेब्रिंग

1
जैसा कि बाद के jsPerf में किसी और ने साबित किया (लिंक ऊपर जोड़ा गया है), यह दृष्टिकोण ES6 string.repeatविधि की तुलना में ~ 2x तेज है । तो अगर आप बहुत सारे स्ट्रिंग पैडिंग कर रहे हैं, तो इसे जरूर आजमाएं।
श्याम हबरकड़ा

5
मैं जेसन की टिप्पणी से भ्रमित हूं - यह उत्तर स्वीकृत से अलग कैसे है?
corwin.amber

1
मैंने आपके jsPerf को देखा। वे परीक्षण आपके फ़ंक्शन और कुछ के लिए हैं जो थोड़ी देर () लूप का उपयोग करते हैं, जो कोई अन्य उच्च श्रेणी निर्धारण उत्तर का उपयोग नहीं करता है। मुझे यकीन नहीं है कि इसका मतलब यह तेज़ है?
होल्डऑफहंगर

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
पूर्णांक गुणन की एक पुनरावर्ती परिभाषा भी है ... हमेशा याद रखें कि पुनरावर्ती में एक 'अभिशाप' है ...
प्रवाह

32
वहाँ भी narwhals और सड़क के नीचे एक शराबी आदमी है, लेकिन न तो प्रासंगिक हैं। पुनरावृत्ति का अभिशाप केवल तब लागू होता है जब एक प्रोग्रामर को यह पता नहीं होता है कि कब उपयुक्त है।
hypno7oad

12
"पुनरावृत्ति का अभिशाप केवल तब लागू होता है जब एक प्रोग्रामर को यह पता नहीं होता है कि कब उसका उपयुक्त है" या जब उन्हें पता नहीं चलता कि यह अनुचित है। जैसे कि एक साधारण स्ट्रिंग पैड फ़ंक्शन के लिए।
दान

यह बहुत सुंदर है और मेरे उपयोग के मामले के लिए पूरी तरह से काम करता है। यदि आपको पाठ संरेखित करने के लिए रिक्त स्थान की आवश्यकता है, तो बस सबसे लंबे तार की लंबाई में फेंक दें =)
डेमन

12
यह सुरुचिपूर्ण है, लेकिन यह फ़ंक्शन के प्रत्येक पुनरावृत्ति पर एक नया स्ट्रिंग भी बनाता है। यह फ़ंक्शन O (n) है जबकि @Samuel द्वारा सबसे लोकप्रिय समाधान O (1) है। दोनों सुरुचिपूर्ण हैं, लेकिन एक बहुत अधिक कुशल है। उस ने कहा, यह एक साफ दृष्टिकोण है, और एक अलग भाषा में भी तेज हो सकता है।
क्रश

40

String.prototype.padStart()और String.prototype.padEnd()वर्तमान में TC39 उम्मीदवार प्रस्ताव हैं: github.com/tc39/proposal-string-pad-start-end (केवल फ़ायरफ़ॉक्स में अप्रैल 2016 तक उपलब्ध है ; एक पॉलीफ़िल उपलब्ध है) देखें।


13
सभी (आधुनिक) ब्राउज़रों द्वारा समर्थित: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
Sphinxxx

आलसी के लिए: myString.padStart(padLength [, padString])औरmyString.padEnd(padLength [, padString])
जोहान Dettmar

1
कृपया कुछ उदाहरण उपयोग जोड़ें, अब यह सभी आधुनिक ब्राउज़रों द्वारा समर्थित किया गया है। इसे प्रोत्साहित किया जाना चाहिए।
फ्रैंकलिन यू

पवित्र बकवास, मैंने आज तक यह कैसे नहीं सुना है ?? यह स्वीकृत उत्तर होना चाहिए।
इलेक्ट्रोविर

29

ECMAScript 2017 स्ट्रिंग प्रोटोटाइप के लिए पैडस्टार्ट विधि जोड़ता है। यह विधि एक स्ट्रिंग को दी गई लंबाई के रिक्त स्थान के साथ पैड करेगी। यह विधि एक वैकल्पिक स्ट्रिंग भी लेती है जिसका उपयोग पैडिंग के लिए रिक्त स्थान के बजाय किया जाएगा।

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

एक पैडएंड विधि भी जोड़ी गई थी जो उसी तरीके से काम करती है।

ब्राउज़र संगतता (और एक उपयोगी पॉलीफ़िल) के लिए इस लिंक को देखें ।


आजकल यहाँ के लिए सबसे अच्छा जवाब ! 2019!
पीटर क्रूस

22

ECMAScript 6 विधि स्ट्रिंग # रिपीट का उपयोग करना , एक पैड फ़ंक्शन जितना सरल है:

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

String#repeatवर्तमान में फ़ायरफ़ॉक्स और क्रोम में ही समर्थित है। अन्य कार्यान्वयन के लिए, कोई निम्नलिखित सरल पॉलीफ़िल पर विचार कर सकता है:

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 विधि स्ट्रिंग # रिपीट और एरो फ़ंक्शंस का उपयोग करना , एक पैड फ़ंक्शन जितना आसान है:

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;
डेविड जी

यह गैर-तार के लिए काम नहीं करता है। के रूप में leftPad(12, ' ', 5)। जबकि मुझे पता है कि सख्ती से बोलना ठीक है, यह शायद सबसे आम उपयोग के मामलों में से एक है (संख्याओं को पैडिंग)। हो सकता है function leftPad(s, c, n) { s = s.toString(); return s.length > len ? s : c.repeat(n - s.length) + s; }। उपयोग करने का functionअर्थ है कि बाईं ओर फ़ाइल के निचले भाग में हो सकता है। अन्यथा आपको यकीनन constन तो उपयोग करना चाहिए varऔर न ही let
3

@ इस सुझाव के लिए धन्यवाद, लेकिन आपका चर क्या है len?
InsOp

lenn
दोह

14

उन दोनों समाधानों में मुख्य चाल arrayएक दिए गए आकार (वांछित लंबाई से अधिक) के साथ एक उदाहरण बनाना है , और फिर तुरंत join()बनाने के लिए विधि को कॉल करना है stringjoin()विधि पारित हो जाता है गद्दी string(रिक्त स्थानों शायद)। चूंकि arrayखाली है, एक परिणाम में stringsशामिल होने की प्रक्रिया के दौरान खाली कोशिकाओं को खाली के रूप में प्रदान किया जाएगा , और केवल पैडिंग रहेगी। यह एक बहुत अच्छी तकनीक है।arraystring


10

डिफ़ॉल्ट मान के साथ पैड

मैंने देखा कि मुझे ज्यादातर समय रूपांतरण / नंबर पैडिंग के लिए पैडलेफ्ट की आवश्यकता है

इसलिए मैंने यह फ़ंक्शन लिखा

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

EDIT @BananaAcid यदि आप एक अपरिभाषित मान या 0 लंबाई स्ट्रिंग जो आपको मिलती है 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 के साथ 'averylongword' पैड करने की कोशिश ... मेरी समस्या नहीं है।


कहा कि मैं तुम्हें एक टिप देता हूं।

अधिकांश समय यदि आप पैड करते हैं तो आप इसे उसी मान 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"
*/

बहुत अच्छा! एक ही परिणाम के साथ आया था, बस एक नोट के रूप में: यह स्ट्रिंग को दी गई अधिकतम लंबाई तक पहुंचता है और एक खाली स्ट्रिंग एक चार बहुत छोटा और अपरिभाषित होगा, जिसके परिणामस्वरूप 'अपरिभाषित' मधुमक्खी का उपयोग किया जाता है और साथ ही ब्याह एक त्रुटि फेंक सकता है। - संयुक्त। return (new Array((b||1)+1).join(c||0)+(a||'')).slice(-(b||2))। और हमेशा की तरह: आप लोग वहां से निकलते हैं, सिर्फ उस कोड को कॉपी न करें जिसे आप नहीं समझते हैं।
केलेअकाइड

1
(नई सरणी (ख || 2) .join (ग || 0) + (एक || ग || 0)) टुकड़ा (बी) ... कम।
cocco


9

सैमुअल के विचारों को उठाते हुए, यहाँ ऊपर की ओर। और एक पुरानी एसक्यूएल स्क्रिप्ट को याद रखें, मैंने इसके साथ प्रयास किया:

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

इस उत्तर को कई अन्य उत्तरों द्वारा उल्लेखित किया गया है इसलिए यह एक डुप्लिकेट है जो कोई नई जानकारी नहीं जोड़ता है। कृपया उत्तर से पहले खोजें।
फ्रैंकलिन यू

यह पूर्ण हस्ताक्षर वाला पहला है। और यह आज तक का एकमात्र उत्तर होना चाहिए।
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  


3

es7 अभी ड्राफ्ट और प्रस्ताव है, लेकिन अगर आप कल्पना को ट्रैक करना चाहते हैं, तो आपके पैड कार्यों की आवश्यकता है:

  1. मल्टी-कैरेक्टर पैड सपोर्ट।
  2. इनपुट स्ट्रिंग को छोटा न करें
  3. पैड अंतरिक्ष के लिए चूक

मेरे पॉलीफ़िल लाइब्रेरी से, लेकिन प्रोटोटाइप एक्सटेंशन के लिए अपने स्वयं के परिश्रम को लागू करें।

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

सुनिश्चित करें कि आप में पात्रों की संख्या, यहाँ शून्य, आपकी कम से कम लंबाई के रूप में कम से कम है। तो वास्तव में, इस मामले में "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 है, और मैं एक जावास्क्रिप्ट स्ट्रिंग-पेडिंग फ़ंक्शन का सुझाव देता हूं। हा!

नंगे-हड्डियों: रिक्त स्थान के साथ दाएं-पैड

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

यहां एक जावास्क्रिप्ट फ़ंक्शन है जो कस्टम सिम्बल के साथ निर्दिष्ट संख्या में पैडिंग जोड़ता है। फ़ंक्शन तीन पैरामीटर लेता है।

    पैडमे -> स्ट्रिंग या बाएं पैड पर संख्या
    पैड -> पैड की संख्या
    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"

* /

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 "

प्रोटोटाइप के साथ गड़बड़ मत करो!
रिहर्सल

1

यदि आप केवल पैड के लिए एक बहुत ही सरल हैकी वन-लाइनर चाहते हैं, तो बस वांछित अधिकतम पैडिंग लंबाई के वांछित पैडिंग कैरेक्टर का एक स्ट्रिंग बनाएं और फिर इसे उस लंबाई में प्रतिस्थापित करें जिसे आप पैड करना चाहते हैं।

उदाहरण: स्ट्रिंग स्टोर eको 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

किसी मित्र ने जावास्क्रिप्ट फ़ंक्शन का उपयोग करने के बारे में पूछा ताकि वह बाईं ओर पैड कर सके। यह हम में से कुछ के बीच एक छोटे से प्रयास में बदल गया, इसे चैट करने के लिए गोल्फ को कोड करें। यह परिणाम था:

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

थोड़ी देर, लेकिन मुझे लगा कि मैं किसी भी तरह साझा कर सकता हूं। मुझे ऑब्जेक्ट में एक प्रोटोटाइप एक्सटेंशन जोड़ना उपयोगी लगा। इस तरह से मैं बाईं और दाईं ओर संख्याओं और तारों को पैड कर सकता हूं। मेरे पास समान उपयोगिताओं वाला एक मॉड्यूल है जिसे मैं अपनी लिपियों में शामिल करता हूं।

// 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-chars निकालें (यदि आप पहले char से निकालते हैं तो पार्सर कुशलता से ऐसा कर सकता है)। यह घातीय वृद्धि है, जिसका अर्थ है कि यह कुछ स्मृति को अस्थायी रूप से बर्बाद कर देता है (आपको अत्यंत विशाल ग्रंथों के साथ ऐसा नहीं करना चाहिए)।

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);
};
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.