web-dev-qa-db-fra.com

Composer un nombre avec des zéros en JavaScript

Duplicate possible:
Comment créer une valeur Zerofilled en utilisant JavaScript?

En JavaScript, j'ai besoin d'un rembourrage.

Par exemple, si j'ai le numéro 9, ce sera "0009". Si j'ai un nombre de dire 10, ce sera "0010". Remarquez comment il contiendra toujours quatre chiffres.

Une façon de faire serait de soustraire le nombre moins 4 pour obtenir le nombre de 0 que je dois mettre.

Y a-t-il une manière plus astucieuse de faire cela?

javascriptformatting
403
Nate Pet

Pas beaucoup de "slick" passe jusqu'à présent:

function pad(n, width, z) {
  z = z || '0';
  n = n + '';
  return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n;
}

Lorsque vous initialisez un tableau avec un nombre, il crée un tableau avec la valeur length définie sur cette valeur, de sorte que le tableau semble contenir autant d'éléments undefined. Bien que certaines méthodes d'instance Array ignorent les éléments de tableau sans valeur, .join() ne le fait pas, ou du moins pas complètement; il les traite comme si leur valeur était la chaîne vide. Ainsi, vous obtenez une copie du caractère zéro (ou de "z" quelconque) entre chacun des éléments du tableau; c'est pourquoi il y a un + 1 dedans.

Exemple d'utilisation:

pad(10, 4);      // 0010
pad(9, 4);       // 0009
pad(123, 4);     // 0123

pad(10, 4, '-'); // --10
571
Pointy
function padToFour(number) {
  if (number<=9999) { number = ("000"+number).slice(-4); }
  return number;
}

Quelque chose comme ca?

Bonus incompréhensible - version simplifiée de l'ES6 sur une seule ligne:

let padToFour = number => number <= 9999 ? `000${number}`.slice(-4) : number;

ES6ismes:

  • let est une variable de portée de bloc (par opposition à la portée fonctionnelle de var)
  • => est une fonction de flèche qui remplace, entre autres, function et est précédée de ses paramètres.
  • Si une fonction de flèche prend un seul paramètre, vous pouvez omettre les parenthèses (donc number =>)
  • Si le corps d'une fonction de flèche comporte une seule ligne commençant par return, vous pouvez omettre les accolades et le mot clé return et utiliser simplement l'expression.
  • Pour obtenir le corps de la fonction sur une seule ligne, j'ai triché et utilisé une expression ternaire
231
Robin Whittleton

Essayer:

String.prototype.lpad = function(padString, length) {
    var str = this;
    while (str.length < length)
        str = padString + str;
    return str;
}

Maintenant tester:

var str = "5";
alert(str.lpad("0", 4)); //result "0005"
var str = "10"; // note this is string type
alert(str.lpad("0", 4)); //result "0010"

DEMO

Dans ECMAScript 8 , nous avons une nouvelle méthode padStart et padEnd qui a la syntaxe ci-dessous.

'string'.padStart (targetLength [ padString]):

Alors maintenant, nous pouvons utiliser

const str = "5";
str.padStart(4, '0'); // '0005'
133
diEcho

C'est drôle, j'ai récemment dû faire ça.

function padDigits(number, digits) {
    return Array(Math.max(digits - String(number).length + 1, 0)).join(0) + number;
}

Utilisez comme:

padDigits(9, 4);  // "0009"
padDigits(10, 4); // "0010"
padDigits(15000, 4); // "15000"

Pas beau, mais efficace.

61
Peter C

Vous avez dit que vous aviez un numéro

String.prototype.padZero= function(len, c){
    var s= '', c= c || '0', len= (len || 2)-this.length;
    while(s.length<len) s+= c;
    return s+this;
}
Number.prototype.padZero= function(len, c){
    return String(this).padZero(len,c);
}
23
kennebec

Vous pouvez faire quelque chose comme ça:

function pad ( num, size ) {
  return ( Math.pow( 10, size ) + ~~num ).toString().substring( 1 );
}

Edit: C’était juste une idée de base pour une fonction, mais ajouter un support pour les grands nombres (ainsi que les entrées invalides) serait probablement mieux:

function pad ( num, size ) {
  if (num.toString().length >= size) return num;
  return ( Math.pow( 10, size ) + Math.floor(num) ).toString().substring( 1 );
}

Cela fait 2 choses:

  1. Si le nombre est supérieur à la taille spécifiée, le nombre sera simplement renvoyé.
  2. L'utilisation de Math.floor(num) à la place de ~~num prendra en charge des nombres plus importants.
12
Robert Messerle

Pour le plaisir, au lieu d’utiliser une boucle pour créer des zéros supplémentaires:

function zeroPad(n,length){
  var s=n+"",needed=length-s.length;
  if (needed>0) s=(Math.pow(10,needed)+"").slice(1)+s;
  return s;
}
3
Phrogz

Puisque vous avez mentionné que la longueur sera toujours de 4, je ne ferai aucune vérification d'erreur pour rendre cette nappe. ;)

function pad(input) {
    var BASE = "0000";
    return input ? BASE.substr(0, 4 - Math.ceil(input / 10)) + input : BASE;
}

Idée: remplacez simplement '0000' par le numéro fourni ... Le problème est que si input vaut 0, je dois le coder en dur pour renvoyer '0000'. LOL.

Cela devrait être assez lisse.

JSFiddler: http://jsfiddle.net/Up5Cr/

2
DashK

Ce n'est pas vraiment 'astucieux' mais il est plus rapide de faire des opérations entières que de faire des concaténations de chaînes pour chaque remplissage 0.

function ZeroPadNumber ( nValue )
{
    if ( nValue < 10 )
    {
        return ( '000' + nValue.toString () );
    }
    else if ( nValue < 100 )
    {
        return ( '00' + nValue.toString () );
    }
    else if ( nValue < 1000 )
    {
        return ( '0' + nValue.toString () );
    }
    else
    {
        return ( nValue );
    }
}

Cette fonction est également codée en dur selon vos besoins particuliers (remplissage à 4 chiffres), elle n’est donc pas générique.

2
xxbbcc