Comment afficher des nombres avec des zéros en tête en JavaScript ?

Question

Existe-t-il un moyen de faire précéder les nombres de zéros non significatifs afin d'obtenir une chaîne de longueur fixe ? Par exemple, 5 devient "05" si je spécifie 2 endroits.

Answer 1

NOTE : Potentiellement périmé. ECMAScript 2017 comprend String.prototype.padStart .

Vous devrez convertir le nombre en chaîne de caractères, car les nombres n'ont pas de sens avec des zéros en tête. Quelque chose comme ça :

function pad(num, size) {
    num = num.toString();
    while (num.length < size) num = "0" + num;
    return num;
}

Ou, si vous savez que vous n'utiliserez jamais plus d'un nombre X de zéros, c'est peut-être mieux. Cela suppose que vous ne voudrez jamais plus de 10 chiffres.

function pad(num, size) {
    var s = "000000000" + num;
    return s.substr(s.length-size);
}

Si vous vous préoccupez des nombres négatifs, vous devrez supprimer la fonction - et le lire.

Answer 2

UPDATE : Petite fonction one-liner utilisant l'ES2017 String.prototype.padStart méthode :

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"

Une autre approche ES5 :

function zeroPad(num, places) {
  var zero = places - num.toString().length + 1;
  return Array(+(zero > 0 && zero)).join("0") + num;
}

zeroPad(5, 2); // "05"
zeroPad(5, 4); // "0005"
zeroPad(5, 6); // "000005"
zeroPad(1234, 2); // "1234" :)

Answer 3

Vous pourriez étendre le Number objet :

Number.prototype.pad = function(size) {
    var s = String(this);
    while (s.length < (size || 2)) {s = "0" + s;}
    return s;
}

Exemples :

(9).pad();  //returns "09"

(7).pad(3);  //returns "007"

Answer 4

De https://gist.github.com/1180489

function pad(a, b){
  return(1e15 + a + '').slice(-b);
}

Avec des commentaires :

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

Answer 5

Juste pour le plaisir (j'avais du temps à tuer), une implémentation plus sophistiquée qui met en cache la chaîne zéro :

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

Si le nombre de rembourrages est important et que la fonction est appelée assez souvent, elle est en fait plus performante que les autres méthodes...