Як я можу зазначити значення за допомогою провідних нулів?

Який рекомендований спосіб заповнити значення в 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.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 придумав логарифмічну варіацію, яка, здається, працює краще.

ПОПЕРЕДЖЕННЯ : Ця функція не працює, якщо число дорівнює нулю (наприклад, нульова панель (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)

Такого підходу, мабуть, достатньо для більшості людей.

Редагувати: Якщо ви хочете зробити це більш загальним, ви можете зробити це:

("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 числа, щоб розмістити нулі праворуч від десяткової коми.

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"

Ось така швидка функція, яку я придумав, щоб виконати роботу. Якщо хтось має більш простий підхід, сміливо діліться!

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

Дуже прямо, я не бачу, як це може бути простішим. Мені чомусь здається, що я багато разів тут, так що люди просто намагаються уникати циклів "за" і "поки" за будь-яку ціну. Використання регулярного виразів, ймовірно, коштуватиме більше циклів для такого тривіального 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/proposed-string-pad-start-end
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

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

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

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'

Особисто після моїх тестів я використовував би метод з циклом, наприклад, 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;
}