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

395

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

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

Wilco
источник
Это действительно недостаточно информации, чтобы ответить. Наиболее распространенным случаем «заполнения нулями», вероятно, является добавление нулей к датам: 01.05.2008> 01.05.2008. Это то, что ты имеешь в виду?
Триптих
6
Для узловых приложений используйте npm install sprintf-jsи требуйте его в sprintf('%0d6', 5);
нужном
function padWithZeroes(n, width) { while(n.length<width) n = '0' + n; return n;} ... при условии, что он nне отрицательный
Паоло
@ Паоло, эта функция не работает, если n числовое. Вам нужно преобразовать n в строку перед whileтем, как получить к нему доступn.length
Ник Ф
1
Один вкладыш без математики или цикла циклов или библиотек? mynum = "0".repeat((n=6-mynum.toString().length)>0?n:0)+mynum;
Адам

Ответы:

226

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

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

Потенциально устаревший : 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 .

Peter Bailey
источник
1
Теперь вам просто нужно позаботиться о числах вроде 50.1234, и у вас есть читабельная версия моего решения ниже! Однако я предположил, что мы просто оставили отступы, а не общие отступы.
coderjoe
7
Не фанат создания нового массива каждый раз, когда вы хотите дополнить значение. Читатели должны знать о потенциальном влиянии памяти и GC, если они выполняют большие # из них (например, на сервере node.js, который выполняет 1000 таких операций в секунду. Ответ @ profitehlolz, по-видимому, будет лучшим решением .)
Брооф
6
Это не работает для отрицательных значений: zeroFill (-10, 7) -> «0000-10»
digitalbath
2
Показатель эффективности среди трех лучших ответов здесь: jsperf.com/left-zero-pad
tomsmeding
12
Начиная с ECMAScript 2017 года, есть встроенная функция padStart .
Томас Никодим
321

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

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
profitehlolz
источник
95
Это очень хорошее решение, лучшее, что я видел. Для ясности, вот более простая версия, которую я использую для заполнения минут при форматировании времени: ('0' + минуты) .slice (-2)
Люк Эресман
17
Это в 5 раз медленнее, чем реализация с циклом while: gist.github.com/4382935
andrewrk
42
Это имеет смертельный дефект с большими, чем ожидалось, числами, что является чрезвычайно распространенным явлением. Например, paddy (888, 2)дает 88и не так, 888как требуется. Этот ответ также не обрабатывает отрицательные числа.
Брок Адамс
8
@BrockAdams, zerofill обычно используется для случаев фиксированной ширины числа / форматирования - поэтому я думаю, что на самом деле было бы менее вероятно (или даже не проблема), если дать 3-значный номер при попытке сделать 2-значный zerofill.
Seaux
1
(«000000» + somenum). Substr (-6,6), где число нулей и -6,6 соответствуют ширине площадки. Та же идея, но срез занимает на один параметр меньше; не уверен, что срез быстрее или медленнее, чем subtr. Конечно, мое решение не требует назначения переменных.
slartibartfast
315

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

var zerofilled = ('0000'+n).slice(-4);
Seaux
источник
27
Хорошо за исключением отрицательных чисел и чисел длиннее 4 цифр.
wberry
12
@wberry это был не готовый код, а скорее простое объяснение основ решения поставленного вопроса. Ака, очень легко определить, является ли число положительным или отрицательным, и добавить соответствующий знак, если это необходимо, поэтому я не хотел кластеризовать свой простой пример с этим. Кроме того, так же просто сделать функцию, принимающую длину цифры в качестве аргумента и использующую ее вместо моих жестко закодированных значений.
Seaux
5
@Seaux, вы сказали: «не могу поверить всем сложным ответам» , а затем начали объяснять себе сложность, когда прокомментировали. Это означает, что вы понимаете, что есть перспективы, с которых ваш ответ не идеален. Отсюда и сложность.
Ом Шанкар
2
@OmShankar под «сложными ответами», я не имел в виду объясненные или подробные ответы (которые, очевидно, приветствуются на этом сайте, хотя мой ответ не так), а скорее ответы, которые содержали ненужную сложность кода.
Seaux
7
Мне нравится этот ответ. В моем конкретном случае я знаю, что числа всегда положительные и никогда не превышают трех цифр, и это часто бывает, когда вы дополняете начальные 0, и ваш ввод хорошо известен. Ницца!
Патрик Чу
110

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

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

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 с вариацией журнала ). Угадайте , который один главно превосходит два других? :)

кодерджо
источник
9
Это хорошо, мне нравится, как это читается и надежно. Единственное, что я хотел бы изменить, - это имя numZerosпараметра, поскольку оно вводит в заблуждение. Это не количество нулей, которое вы хотите добавить, это минимальная длина, которой должно быть число. Лучшее имя будет numLengthили даже length.
Чувственный
13
+1. В отличие от ответов с более высоким рейтингом, этот обрабатывает отрицательные числа и не возвращает грубых ошибок при переполнении !!?!
Брок Адамс
10
Показатель эффективности среди трех лучших ответов здесь: jsperf.com/left-zero-pad
tomsmeding
4
Я увеличил производительность этого ответа более чем на 100%, используя логарифмы. См. Логарифмический тестовый пример на http://jsperf.com/left-zero-pad/10
XDR
2
Исходное решение лучше, логарифмическая вариация не работает, если numможет быть ноль ...
Ондра С.
69

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

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

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

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

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

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

number.toString().padStart(padding, "0")
четбокса
источник
Это плохо, на больших числах и отрицательных числах. number = 123456789, с кодом, приведенным выше, например.
Брок Адамс
Это решение является лучшим из возможных для определенных сценариев! Я понятия не имею, почему мы не придумали это раньше. Сценарий таков: у вас есть число, которое всегда положительно [как упомянул Брок], и вы знаете, что оно не займет больше символов, чем ваш лимит. В нашем случае у нас есть оценка, которую мы храним в Amazon SDB. Как вы знаете, SDB не может сравнивать числа, поэтому все оценки должны быть дополнены нулями. Это очень легко и эффективно!
Кристиан
4
Извините, я должен был упомянуть, что это не будет работать для отрицательных чисел. Я думаю, что это имеет дело с более распространенным положительным числом, хотя. Это делает то, что мне нужно, по крайней мере!
chetbox
Нужно это снова и понял, что вам не нужно new String. Вы можете просто использовать строковые литералы.
chetbox
3
(new Array(padding + 1).join("0")можно заменить на"0".repeat(padding)
Павел
34

Современные браузеры теперь поддерживают 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"

Flimm
источник
@Flimm не стесняйтесь редактировать это в ответе :) Это было написано 4 года назад, так что я уверен, что сейчас все изменилось
Стерлинг Арчер
27

К сожалению, существует множество ненужных сложных предложений для этой проблемы, обычно включающих написание собственной функции для выполнения математических или строковых операций или вызова сторонней утилиты. Тем не менее, есть стандартный способ сделать это в базовой библиотеке 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()

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

Daniel Barbalace
источник
Вау, это супер чистое решение и работает в node.js.
Jishi
Я усмехнулся, когда прочитал вступление - «ненужные сложные предложения». Разработка программного обеспечения, как и во всех инженерных дисциплинах, предполагает взвешенные компромиссы. Я попробовал этот «стандартный способ» сам - и рассчитал его. Это определенно работает, но я бы никогда не выбрал его для любого повторяющегося приложения из-за того, насколько оно медленное по сравнению со многими другими «домашними» решениями.
Bearvarine
1
Правда, многие встроенные функции JavaScript плохо работают при циклическом перемещении большого количества данных, но я бы сказал, что для этого не следует использовать JavaScript, даже на стороне сервера, например Node.js. Если у вас много данных для обработки на стороне сервера, вам следует использовать более совершенную платформу, например .NET или Java. Если вы обрабатываете данные на стороне клиента для отображения конечному пользователю, вам следует обрабатывать только те данные, которые вы в данный момент отображаете на экране конечного пользователя. Например, визуализируйте только видимые строки таблицы и не обрабатывайте данные для других дорог.
Даниэль Барбалас
21

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

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/

jfriend00
источник
@BrockAdams - исправлено для обоих упомянутых вами случаев. Если число уже равно ширине заливки, заливка не добавляется.
jfriend00
Спасибо; +1. Отрицательные числа немного отличаются от обычного соглашения. В вашем тестовом случае, -88должен дать "-00088", например.
Брок Адамс
1
@BrockAdams - Я не уверен , является ли призвание zeroFill(-88, 5)должно производить -00088или -0088? Я думаю, это зависит от того, хотите ли вы, чтобы widthаргумент был всей шириной числа или только количеством цифр (не считая отрицательного знака). Реализатор может легко переключить поведение, чтобы не включать отрицательный знак, просто удалив --widthстроку кода.
jfriend00
19

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

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

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

Иоганн Филипп Стратхаузен
источник
1
Я получил y="0005"с вышеизложенным, y = (new Array(count + 1 - x.toString().length)).join('0') + x;это то , что дал мнеy="000005"
forforf
3
@ OrrSiloni: самое короткое кодовое решение на самом деле('0000'+n).slice(-4)
Seaux
14

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

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

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

    return result;
}
Wilco
источник
Я не думаю, что будет «более простое» решение - оно всегда будет какой-то функцией. Мы могли бы обсудить алгоритм, но в конце концов вы все равно получите функцию, которая обнуляет число.
Питер Бейли
Мой общий совет - использовать циклы for, поскольку они обычно более стабильны и быстрее в языках ECMAScript (ActionScript 1-3 и JavaScript)
cwallenpoole
Или вообще пропустить итерацию;)
Питер Бейли
Более простая функция? Возможно нет. Тот, который не зацикливается? Это возможно ... хотя алгоритм не совсем тривиален.
coderjoe
1
Вау, почти все вышеприведенные комментарии неверны. Решение @ profitehlolz более простое и подходит для встраивания (не обязательно должно быть функцией). Между тем, for.vs. whileпроизводительность не настолько отличается, чтобы быть интересной: jsperf.com/fors-vs-
while/
12

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

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

Где offset10 ^^ цифр.

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

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

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

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

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

broofa
источник
12

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

Функция:

/** 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 цифр.

Vitim.us
источник
11

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

(value+100000).toString().slice(-5) // "00123" with value=123
Jasto Salto
источник
9

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

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

function zeroPad(x, y)
{
   y = Math.max(y-1,0);
   var n = (x / Math.pow(10,y)).toFixed(y);
   return n.replace('.','');  
}
гроза с дождем
источник
9

Я не видел, чтобы кто-то указывал на тот факт, что когда вы используете 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));

Стивен Куан
источник
8

После долгого и долгого тестирования 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'
Джек Б
источник
Я поместил это в jsfiddle, чтобы другие могли быстро его протестировать, добавив вашу версию кода: jsfiddle.net/kevinmicke/vnvghw7y/2 Ваша версия всегда очень конкурентоспособна, а иногда и самая быстрая. Спасибо за довольно исчерпывающее тестирование.
Кевинмике
8

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

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'
Джек Аллан
источник
8

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

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

Льюис
источник
Очевидно, что самое элегантное решение я бы просто const numStr = String(num)return '0'.repeat(len - numStr.length) + numStr;
изменил,
8

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

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

Ухищрение
источник
5

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

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

Изобразительное искусство
источник
1
Лучше:var zfill = _.partialRight(_.padStart, '0');
Droogans
3
Некоторые люди, вероятно, будут возражать «Я не хочу использовать lodash», но это уже вряд ли является действительным аргументом, поскольку вы можете установить только эту функцию:, а npm install --save lodash.padleftзатем import padLeft from 'lodash.padleft'пропустите_.
Andy
5

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

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

output: "02"

MRE
источник
(8).toLocaleString(undefined, {minimumIntegerDigits: 5})возвращается "00.008"для меня, основываясь на моей локали.
le_m
5

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

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

Артур
источник
То же, что и другие?
Фабио говорит восстановить Монику
4

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

zeroPad = function (num, count) {
    var pad = (num + '').length - count;
    while(--pad > -1) {
        num = '0' + num;
    }
    return num;
};
Джонатан Нил
источник
Я думаю, что вы хотите сделать pad = count - (num + '').length. отрицательные числа плохо обрабатываются, но, кроме того, это не плохо. +1
nickf
3

Мое решение

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
Александар Топлек
источник
3

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

function padZero(s, n) {
    s = s.toString(); // in case someone passes a number
    return s.length >= n ? s : padZero('0' + s, n);
}
оборота lex82
источник
padZero (223, 3) завершается неудачно с '0223'
Сержиньо
Ну, я предположил, что эта функция вызывается со строкой в ​​качестве первого параметра. Однако я это исправил.
lex82
2

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

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"
Родриго
источник
1
-1 monkeypatching пространство имен верхнего уровня в javascript - плохая практика.
Джереми Уолл
2
Верно для объектов и массивов, но String - неплохо
Родриго,
2
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

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

ура

Madbreaks
источник
Я думаю, что это должно быть больше похоже на: var s = String(toPad); return (s.length < length) ? new Array(length - s.length + 1).join('0') + s : s;если вы это исправите, я уберу свой отрицательный голос.
drewish
@drewish Спасибо, что поймали это, я согласен с вашей правкой (за исключением хардкодированного 0объединения символов :) - Ответ обновлен.
Madbreaks
Я думаю, что было бы лучше сохранить строку во временной переменной. Я сделал несколько сравнительных тестов здесь: jsperf.com/padding-with-memoization. У него также есть тесты для использования нового в "новом массиве", результаты для нового повсюду, но запоминание похоже на путь.
drewish
2

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

function zerofill(number,length) {
    var output = number.toString();
    while(output.length < length) {
      output = '0' + output;
    }
    return output;
}
d4nyll
источник