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

Каков рекомендуемый способ обнуления значения в JavaScript? Я полагаю, что мог бы создать пользовательскую функцию для добавления нулей к типизированному значению, но мне интересно, есть ли более прямой способ сделать это?

Примечание. Под «заполненным нулями» я подразумеваю это в смысле слова в базе данных (где 6-значное представление с нулевым заполнением числа 5 будет «000005»).

Примечание для читателей!

Как отметили комментаторы, это решение является «умным», и, как это часто бывает с умными решениями, оно требует большого объема памяти и относительно медленно. Если производительность вас беспокоит, не используйте это решение!

Потенциально устаревший : ECMAScript 2017 включает в себя String.prototype.padStart, а Number.prototype.toLocaleString существует с версии ECMAScript 3.1. Пример:

var n=-0.1;
n.toLocaleString('en', {minimumIntegerDigits:4,minimumFractionDigits:2,useGrouping:false})

... выдаст «-0000.10».

// or 
const padded = (.1+"").padStart(6,"0");
`-${padded}`

... выведет "-0000.1".

Простая функция - это все, что вам нужно

function zeroFill( number, width )
{
  width -= number.toString().length;
  if ( width > 0 )
  {
    return new Array( width + (/\./.test( number ) ? 2 : 1) ).join( '0' ) + number;
  }
  return number + ""; // always return a string
}

Вы могли бы запечь это в библиотеке, если вы хотите сохранить пространство имен или что-то еще. Как с расширением jQuery .

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

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

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

> zeroPad(50,4);
"0050"

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

> zeroPad(51234, 3);
"51234"

Десятичные числа тоже хорошо!

> zeroPad(51.1234, 4);
"0051.1234"

Если вы не против загрязнения глобального пространства имен, вы можете добавить его в Number напрямую:

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

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

Вот то, что я использовал, чтобы дополнить число до 7 символов.

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

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

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

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

Изменить 2: Обратите внимание, что начиная с ES2017 вы можете использовать String.prototype.padStart:

number.toString().padStart(padding, "0")

Современные браузеры теперь поддерживают padStart, вы можете просто сделать:

string.padStart(maxLength, "0");

Пример:

string = "14";
maxLength = 5; // maxLength is the max string length, not max # of fills
res = string.padStart(maxLength, "0");
console.log(res); // prints "00014"

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

var amount = 5;

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

Это приведет к значению «005» для текста. Вы также можете использовать функцию toLocaleString для Number, чтобы заполнить нули справа от десятичной точки.

var amount = 5;

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

Это даст значение «5,00» для текста. Измените useGrouping на true, чтобы использовать запятые для тысяч.

Обратите внимание, что использование аргументов toLocaleString()with localesи стандартизировано отдельно в ECMA-402 , а не в ECMAScript. На сегодняшний день некоторые браузеры реализуют только базовую поддержку , то есть могут игнорировать любые аргументы.optionstoLocaleString()

Полный пример

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

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"

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

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

Где offset10 ^^ цифр.

Например, заполнение до 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);
};

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

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

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

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

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

x = целое число для заполнения
y = количество нулей для заполнения

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

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

Единственное решение вопроса ОП, 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));

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

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

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

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

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

Итак, какой цикл использовать? Ну, это было бы whileпетлей. forЦикл по - прежнему быстро, но 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;
}

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

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'

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

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

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

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

Вот ссылка на MDN https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

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

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

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

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

output: "02"

Просто другое решение, но я думаю, что оно более разборчиво.

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

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

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

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

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

Некоторая мартышка тоже работает

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