Как я могу заполнить значение с ведущими нулями?

простой способ. Вы можете добавить строковое умножение для пэда и превратить его в функцию.

var pad = "000000";
var n = '5';
var result = (pad+n).slice(-pad.length);

как функция,

function paddy(num, padlen, padchar) {
    var pad_char = typeof padchar !== 'undefined' ? padchar : '0';
    var pad = new Array(1 + padlen).join(pad_char);
    return (pad + num).slice(-pad.length);
}
var fu = paddy(14, 5); // 00014
var bar = paddy(2, 4, '#'); // ###2

Я не могу поверить, что все сложные ответы здесь... Просто используйте это:

var zerofilled = ('0000'+n).slice(-4);

Я на самом деле должен был придумать что-то вроде этого недавно. Я решил, что должен быть способ сделать это без использования петель.

вот что я придумал.

function zeroPad(num, numZeros) {
    var n = Math.abs(num);
    var zeros = Math.max(0, numZeros - Math.floor(n).toString().length );
    var zeroString = Math.pow(10,zeros).toString().substr(1);
    if( num < 0 ) {
        zeroString = '-' + zeroString;
    }

    return zeroString+n;
}

тогда просто используйте его, предоставляя число до нуля pad:

> zeroPad(50,4);
"0050"

если число больше, чем заполнение, число будет расширяться за пределы заполнения:

> zeroPad(51234, 3);
"51234"

десятичные тоже хорошо!

> zeroPad(51.1234, 4);
"0051.1234"

если вы не против загрязнения глобального пространства имен вы можно добавить его в число непосредственно:

Number.prototype.leftZeroPad = function(numZeros) {
    var n = Math.abs(this);
    var zeros = Math.max(0, numZeros - Math.floor(n).toString().length );
    var zeroString = Math.pow(10,zeros).toString().substr(1);
    if( this < 0 ) {
        zeroString = '-' + zeroString;
    }

    return zeroString+n;
}

и если вы предпочитаете, чтобы десятичные числа занимали место в дополнении:

Number.prototype.leftZeroPad = function(numZeros) {
    var n = Math.abs(this);
    var zeros = Math.max(0, numZeros - n.toString().length );
    var zeroString = Math.pow(10,zeros).toString().substr(1);
    if( this < 0 ) {
        zeroString = '-' + zeroString;
    }

    return zeroString+n;
}

Ура!

---

---

XDR придумал логарифмическая вариация это, кажется, работает лучше.

предупреждение: эта функция не работает, если num равно нулю(например, zeropad (0, 2))

function zeroPad (num, numZeros) {
    var an = Math.abs (num);
    var digitCount = 1 + Math.floor (Math.log (an) / Math.LN10);
    if (digitCount >= numZeros) {
        return num;
    }
    var zeroString = Math.pow (10, numZeros - digitCount).toString ().substr (1);
    return num < 0 ? '-' + zeroString + an : zeroString + an;
}

---

говоря о производительности, tomsmeding сравнил 3 лучших ответа (4 с изменением журнала). Угадайте, какой из них в основном превзошли две другие? :)

вот что я использовал для заполнения числа до 7 символов.

("0000000" + number).slice(-7)

этот подход, вероятно, достаточно для большинства людей.

Edit: если вы хотите сделать его более общим, вы можете сделать это:

("0".repeat(padding) + number).slice(-padding)

к сожалению, есть много ненужных сложных предложений для этой проблемы, обычно связанных с написанием собственной функции для выполнения математических или строковых манипуляций или вызова сторонней утилиты. Однако существует стандартный способ сделать это в базовой библиотеке JavaScript только с одной строкой кода. Возможно, стоит обернуть эту строку кода в функцию, чтобы избежать необходимости указывать параметры, которые вы никогда не хотите изменять, например локальное имя или стиль.

var amount = 5;

var text = amount.toLocaleString('en-US',
{
    style: 'decimal',
    minimumIntegerDigits: 3,
    useGrouping: false
});

это приведет к значению " 005 " для текста. Вы также можете использовать функцию toLocaleString числа для заполнения нулей в правой части десятичной точки.

var amount = 5;

var text = amount.toLocaleString('en-US',
{
    style: 'decimal',
    minimumFractionDigits: 2,
    useGrouping: false
});

это приведет к значению" 5.00 " для текста. Измените useGrouping на true, чтобы использовать разделители запятых для тысяч.

обратите внимание, что с помощью toLocaleString() С locales и options аргументы - это стандартизированный по отдельности в ECMA-402, не в ECMAScript. Как сегодня, некоторые браузеры только реализовать базовую поддержку, т. е. toLocaleString() может игнорировать любые аргументы.

Пример

если заранее известно, что номер заполнения не превышает определенного значения, есть другой способ сделать это без циклов:

var fillZeroes = "00000000000000000000";  // max number of zero fill ever asked for in global

function zeroFill(number, width) {
    // make sure it's a string
    var input = number + "";  
    var prefix = "";
    if (input.charAt(0) === '-') {
        prefix = "-";
        input = input.slice(1);
        --width;
    }
    var fillAmt = Math.max(width - input.length, 0);
    return prefix + fillZeroes.slice(0, fillAmt) + input;
}

тестовые случаи здесь:http://jsfiddle.net/jfriend00/N87mZ/

быстрый и грязный способ:

y = (new Array(count + 1 - x.toString().length)).join('0') + x;

для x = 5 и count = 6 у вас будет y = "000005"

в предложенном (Этап 3) методе ES2017 .padStart() теперь вы можете просто сделать (при реализации / поддержке):

string.padStart(maxLength, "0"); //max length is the max string length, not max # of fills

вот быстрая функция, которую я придумал, чтобы сделать эту работу. Если у кого есть более простой подход, не стесняйтесь поделиться!

function zerofill(number, length) {
    // Setup
    var result = number.toString();
    var pad = length - result.length;

    while(pad > 0) {
        result = '0' + result;
        pad--;
    }

    return result;
}

поздно на вечеринку здесь, но я часто использую эту конструкцию для выполнения специального заполнения некоторого значения n, известный как положительный, десятичный:

(offset + n + '').substr(1);

здесь offset в 10^^цифр.

например, заполнение до 5 цифр, где n = 123:

(1e5 + 123 + '').substr(1); // => 00123

шестнадцатеричная версия этого немного более подробна:

(0x100000 + 0x123).toString(16).substr(1); // => 00123

Примечание 1: мне также нравится решение @profitehlolz, которое является Строковой версией этого, используя отличный отрицательный индекс slice () особенность.

Я действительно не знаю, почему, но никто не сделал это самым очевидным способом. Вот это моя реализация.

функция:

/** Pad a number with 0 on the left */
function zeroPad(number, digits) {
    var num = number+"";
    while(num.length < digits){
        num='0'+num;
    }
    return num;
}

прототип:

Number.prototype.zeroPad=function(digits){
    var num=this+"";
    while(num.length < digits){
        num='0'+num;
    }
    return(num);
};

очень просто, я не вижу никакого способа, как это может быть проще. По какой-то причине я, кажется, много раз здесь так, люди просто пытаются избежать " Для " и "в то время как" петли любой ценой. Использование регулярного выражения, вероятно, будет стоить намного больше циклов для такого тривиального 8-значного заполнения.

Я использую этот снипет, чтобы получить 5-значное представление

(value+100000).toString().slice(-5) // "00123" with value=123

сила математики!

x = целое число в pad
y = количество нулей в колодке

function zeroPad(x, y)
{
   y = Math.max(y-1,0);
   var n = (x / Math.pow(10,y)).toFixed(y);
   return n.replace('.','');  
}

первый параметр-любое вещественное число, второй параметр-положительное целое число, указывающее минимальное количество цифр слева от десятичной точки, а третий параметр-необязательное положительное целое число, указывающее число, если цифры справа от десятичной точки.

function zPad(n, l, r){
    return(a=String(n).match(/(^-?)(\d*)\.?(\d*)/))?a[1]+(Array(l).join(0)+a[2]).slice(-Math.max(l,a[2].length))+('undefined'!==typeof r?(0<r?'.':'')+(a[3]+Array(r+1).join(0)).slice(0,r):a[3]?'.'+a[3]:''):0
}

так

           zPad(6, 2) === '06'
          zPad(-6, 2) === '-06'
       zPad(600.2, 2) === '600.2'
        zPad(-600, 2) === '-600'
         zPad(6.2, 3) === '006.2'
        zPad(-6.2, 3) === '-006.2'
      zPad(6.2, 3, 0) === '006'
        zPad(6, 2, 3) === '06.000'
    zPad(600.2, 2, 3) === '600.200'
zPad(-600.1499, 2, 3) === '-600.149'

Не изобретайте велосипед, используйте подчеркивание строки:

jsFiddle

var numToPad = '5';

alert(_.str.pad(numToPad, 6, '0')); // yields: '000005'

это решение ES6.

function pad(num, len) {
  return '0'.repeat(len - num.toString().length) + num;
}
alert(pad(1234,6));

после долгого, долгого времени тестирования 15 различных функций / методов, найденных в ответах на эти вопросы, я теперь знаю, что является лучшим (самым универсальным и быстрым).

я взял 15 функций / методов из ответов на этот вопрос и сделал скрипт для измерения времени, необходимого для выполнения 100 пэдов. Каждый Блокнот будет заполнять число 9 С 2000 нули. Это может показаться чрезмерным, и это, но это дает вам хорошее представление о масштабировании функции.

код, который я использовал, можно найти здесь: https://gist.github.com/NextToNothing/6325915

не стесняйтесь изменять и тестировать код самостоятельно.

для того, чтобы получить наиболее универсальный метод, вы должны использовать цикл. Это потому, что с очень большим количеством других, скорее всего, потерпят неудачу, в то время как, это будет успешным.

Итак, какой цикл использовать? Ну, это было бы while петли. А for цикл по-прежнему быстро, но a while цикл просто немного быстрее (несколько МС) - и чище.

ответы как Wilco,Aleksandar Toplek или Vitim.us сделает работу отлично.

лично я попробовал другой подход. Я попытался использовать рекурсивную функцию для заполнения строки / числа. Это сработало лучше, чем методы, соединяющие массив, но, тем не менее, не работало так быстро, как цикл for.

моя функция:

function pad(str, max, padder) {
  padder = typeof padder === "undefined" ? "0" : padder;
  return str.toString().length < max ? pad(padder.toString() + str, max, padder) : str;
}

вы можете использовать мою функцию с или без, установка переменной заполнения. Вот так:

pad(1, 3); // Returns '001'
// - Or -
pad(1, 3, "x"); // Returns 'xx1'

лично, после моих тестов, я бы использовал метод с циклом while, как Aleksandar Toplek или Vitim.us. Однако я бы немного изменил его, чтобы вы могли установить строку заполнения.

Итак, я бы использовал этот код:

function padLeft(str, len, pad) {
    pad = typeof pad === "undefined" ? "0" : pad + "";
    str = str + "";
    while(str.length < len) {
        str = pad + str;
    }
    return str;
}

// Usage
padLeft(1, 3); // Returns '001'
// - Or -
padLeft(1, 3, "x"); // Returns 'xx1'

вы также можете использовать его в качестве функции-прототипа, используя этот код:

Number.prototype.padLeft = function(len, pad) {
    pad = typeof pad === "undefined" ? "0" : pad + "";
    var str = this + "";
    while(str.length < len) {
        str = pad + str;
    }
    return str;
}

// Usage
var num = 1;

num.padLeft(3); // Returns '001'
// - Or -
num.padLeft(3, "x"); // Returns 'xx1'

ECMAScript 2017: используйте padStart или padEnd

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

Подробнее:

• https://github.com/tc39/proposal-string-pad-start-end
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

Я не видел, чтобы кто-то указывал на то, что когда вы используете строку.прототип.substr () с отрицательным числом он считает справа.

одно линейное решение вопроса OP, 6-значное нулевое представление числа 5, является:

console.log(("00000000" + 5).substr(-6));

обобщая, мы получим:

function pad(num, len) { return ("00000000" + num).substr(-len) };

console.log(pad(5, 6));
console.log(pad(45, 6));
console.log(pad(345, 6));
console.log(pad(2345, 6));
console.log(pad(12345, 6));

последний способ сделать это намного проще:

var number = 2
number.toLocaleString(undefined, {minimumIntegerDigits:2})

output: "02"

во всех современных браузерах, вы можете использовать

numberStr.padStart(numberLength, "0");

function zeroFill(num, numLength) {
  var numberStr = num.toString();

  return numberStr.padStart(numLength, "0");
}

var numbers = [0, 1, 12, 123, 1234, 12345];

numbers.forEach(
  function(num) {
    var numString = num.toString();
    
    var paddedNum = zeroFill(numString, 5);

    console.log(paddedNum);
  }
);

вот ссылка MDNhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

Это меньше родной, но может быть самым быстрым...

zeroPad = function (num, count) {
    var pad = (num + '').length - count;
    while(--pad > -1) {
        num = '0' + num;
    }
    return num;
};

мое решение

Number.prototype.PadLeft = function (length, digit) {
    var str = '' + this;
    while (str.length < length) {
        str = (digit || '0') + str;
    }
    return str;
};

использование

var a = 567.25;
a.PadLeft(10); // 0000567.25

var b = 567.25;
b.PadLeft(20, '2'); // 22222222222222567.25

Не то, чтобы этот вопрос требует больше ответов, но я думал, что добавлю простую версию lodash этого.

_.padLeft(number, 6, '0')

просто другое решение, но я думаю, что это более читаемым.

function zeroFill(text, size)
{
  while (text.length < size){
  	text = "0" + text;
  }
  
  return text;
}

почему бы не использовать рекурсию?

function padZero(s, n) {
    s = s.toString(); // in case someone passes a number
    return s.length >= n ? s : padZero('0' + s, n);
}

некоторые monkeypatching также работает

String.prototype.padLeft = function (n, c) {
  if (isNaN(n))
    return null;
  c = c || "0";
  return (new Array(n).join(c).substring(0, this.length-n)) + this; 
};
var paddedValue = "123".padLeft(6); // returns "000123"
var otherPadded = "TEXT".padLeft(8, " "); // returns "    TEXT"

function pad(toPad, padChar, length){
    return (String(toPad).length < length)
        ? new Array(length - String(toPad).length + 1).join(padChar) + String(toPad)
        : toPad;
}

pad(5, 0, 6) = 000005

pad('10', 0, 2)= 10 // don't pad if not necessary

pad('S', 'O', 2) = SO

...так далее.

Ура

на простой, самое прямое решение, которое вы найдете.

function zerofill(number,length) {
    var output = number.toString();
    while(output.length < length) {
      output = '0' + output;
    }
    return output;
}