Is er een manier om voorloopnullen voor getallen te plaatsen, zodat dit resulteert in een reeks van vaste lengte? 5wordt bijvoorbeeld "05"als ik 2 plaatsen opgeef.
Antwoord 1, autoriteit 100%
OPMERKING: mogelijk verouderd. ECMAScript 2017 bevat
String.prototype.padStart.
Je moet het getal naar een tekenreeks converteren, aangezien getallen met voorloopnullen niet logisch zijn. Zoiets als dit:
function pad(num, size) {
num = num.toString();
while (num.length < size) num = "0" + num;
return num;
}
Of, als je weet dat je nooit meer dan X aantal nullen zult gebruiken, is dit misschien beter. Dit veronderstelt dat je nooit meer dan 10 cijfers wilt.
function pad(num, size) {
var s = "000000000" + num;
return s.substr(s.length-size);
}
Als je om negatieve getallen geeft, moet je de -verwijderen en lezen.
Antwoord 2, autoriteit 46%
UPDATE:Kleine one-liner-functie met behulp van de ES2017 String.prototype.padStartmethode:
const zeroPad = (num, places) => String(num).padStart(places, '0')
console.log(zeroPad(5, 2)); // "05"
console.log(zeroPad(5, 4)); // "0005"
console.log(zeroPad(5, 6)); // "000005"
console.log(zeroPad(1234, 2)); // "1234"Antwoord 3, autoriteit 28%
U zou het object Numberkunnen uitbreiden:
Number.prototype.pad = function(size) {
var s = String(this);
while (s.length < (size || 2)) {s = "0" + s;}
return s;
}
Voorbeelden:
(9).pad(); //returns "09"
(7).pad(3); //returns "007"
Antwoord 4, autoriteit 7%
Van https://gist.github.com/1180489
function pad(a, b){
return(1e15 + a + '').slice(-b);
}
Met opmerkingen:
function pad(
a, // the number to convert
b // number of resulting characters
){
return (
1e15 + a + // combine with large number
"" // convert to string
).slice(-b) // cut leading "1"
}
Antwoord 5
function zfill(num, len) {return (Array(len).join("0") + num).slice(-len);}
Antwoord 6
Voor de lol (ik had wat tijd om te doden), een meer geavanceerde implementatie die de zero-string in de cache opslaat:
pad.zeros = new Array(5).join('0');
function pad(num, len) {
var str = String(num),
diff = len - str.length;
if(diff <= 0) return str;
if(diff > pad.zeros.length)
pad.zeros = new Array(diff + 1).join('0');
return pad.zeros.substr(0, diff) + str;
}
Als het aantal opvullingen groot is en de functie vaak genoeg wordt aangeroepen, presteert deze beter dan de andere methoden…