У меня есть номер в Javascript, который, как я знаю, меньше 10000, а также неотрицательный. Я хочу отобразить его как четырехзначное число с ведущими нулями. Есть ли что-нибудь более элегантное, чем следующее?
if(num<10) num="000"+num;
else if(num<100) num="00"+num;
else if(num<1000) num="0"+num;
Я хочу что-то, что встроено в Javascript, но я ничего не могу найти.
Поскольку заполнение ES2017 до минимальной длины может быть сделано просто с помощью String.prototype.padStart и String.prototype.padEnd:
let num = 3
let str = num.toString().padStart(3, "0")
console.log(str) // "003"
Или если только вся часть поплавка должна быть фиксированной длины:
let num = 3.141
let arr = num.toString().split(".")
arr[0] = arr[0].padStart(3, "0")
let str = arr.join(".")
console.log(str) // "003.141"
Самый простой способ, о котором я думаю, это:
("000" + num).slice(-4)
Мягкий номер - это строка.
Когда вы добавляете число в строку, оно преобразуется в строку.
Strings имеет метод slice, который возвращает фрагмент строки фиксированной длины.
Если длина отрицательна, возвращаемая строка вырезается из конца строки.
проверить:
var num=12;
console.log(("000" + num).slice(-4)); // Will show "0012"
Конечно, это работает только для положительных целых чисел до 4 цифр. Несколько более сложное решение, которое будет обрабатывать натуральные числа:
'0'.repeat( Math.max(4 - num.toString().length, 0)) + num
Создайте строку, повторяя добавление нулей, если количество цифр (длина строки) меньше 4 Добавьте число, которое затем будет преобразователем в строку.
Я не думаю, что для этого нужно что-то "встроить" в язык JavaScript. Вот простая функция, которая делает это:
function FormatNumberLength(num, length) {
var r = "" + num;
while (r.length < length) {
r = "0" + r;
}
return r;
}
FormatNumberLength(10000, 5) outputs '10000'
FormatNumberLength(1000, 5) outputs '01000'
FormatNumberLength(100, 5) outputs '00100'
FormatNumberLength(10, 5) outputs '00010'
Это может помочь:
String.prototype.padLeft = function (length, character) {
return new Array(length - this.length + 1).join(character || '0') + this;
}
var num = '12';
alert(num.padLeft(4, '0'));
Смешной (но интересный) способ префикса чисел с нулями:
function FormatInteger(num, length) {
return (num / Math.pow(10, length)).toFixed(length).substr(2);
}
Как насчет чего-то вроде этого:
function prefixZeros(number, maxDigits)
{
var length = maxDigits - number.toString().length;
if(length <= 0)
return number;
var leadingZeros = new Array(length + 1);
return leadingZeros.join('0') + number.toString();
}
//Call it like prefixZeros(100, 5); //Alerts 00100
Я думаю, что самый компактный, но интуитивный способ:
function toFixedLength(input, length, padding) {
padding = String(padding || "0");
return (padding.repeat(length) + input).slice(-length);
}
Метод slice здесь можно заменить на substr, если это более интуитивно понятно для кодера.
Последний с методом ES6 repeat():
const length_required = 5;
let num = 10;
num = "0".repeat(length_required - String(num).length) + num;
console.log(num)
// output: 00010
let num = 1000;
num = "0".repeat(length_required - String(num).length) + num;
console.log(num)
// output: 01000
Вы можете сходить с ума с помощью таких методов:
function PadDigits(input, totalDigits)
{
var result = input;
if (totalDigits > input.length)
{
for (i=0; i < (totalDigits - input.length); i++)
{
result = '0' + result;
}
}
return result;
}
Но это не облегчит жизнь. С# имеет такой метод, как PadLeft и PadRight в классе String, к сожалению Javascript не имеет этой функциональной сборки
Я искал ответ, но я думаю, что это лучший функциональный подход (ES6):
const formatNumberToString = (num, minChars) => {
return num.toString().length < minChars
? formatNumberToString(`0${num}`, minChars)
: num.toString()
}
// formatNumberToString(12, 4) // "0012"
// formatNumberToString(12, 5) // "00012"
// formatNumberToString(1, 4) // "0001"
// formatNumberToString(1, 2) // "01"
// formatNumberToString(12, 2) // "12"
// formatNumberToString(12, 1) // "12"
это может быть реализовано только в одной строке
Цикл "while" должен сделать это достаточно простым.
function formatLength(a) {
var num = document.getElementById(a)
while (num.value.length < 4) {
num.value = '0' + num.value
}
}
Это будет проходить до тех пор, пока длина значения num не достигнет 4 цифр (предполагается, что вы прошли в идентификаторе элемента числа в качестве аргумента)
У меня возникла такая же проблема, и я нашел компактный способ ее решения. Если бы мне пришлось использовать его несколько раз в моем коде, или если бы я делал это для четырех цифр, я бы использовал одно из других предлагаемых решений, но этот способ позволяет мне выразить все это в выражении:
((x<10)?"000": (x<100)?"00": (x<1000)?"0": "") + x
На самом деле это то же самое, что и ваш код, но с использованием тернарного оператора вместо операторов "if-else" (и перемещения "+ x", который всегда будет частью выражения, вне условного кода).
Другой:
function format_number_length(num, length) {
var r = num.toString();
if (r.length<length) r = Array(length - r.length + 1).join('0') + r;
return r;
}
function paddedNumber(number, minLength)
{
var numStr = number.toString();
while (numStr.length < minLength)
numStr = '0' + numStr;
return numStr;
}
Я знаю, что этот вопрос довольно старый, но для тех, кто ищет что-то похожее на форматирование строк в Java или Python, у меня есть следующие вспомогательные методы:
String.format = (...args) => {
if( args.length == 0 ){
throw new Error("String format error: You must provide at least one argument");
}
const delimiter = "@LIMIT*";
const format = String(args.shift(1,0)).replace(/(%[0-9]{0,}[sd])/g, delimiter+"$1"+delimiter).split(delimiter); // First element is the format
if( [...format].filter(el=>el.indexOf("%")>-1).length != args.length ){
throw new Error("String format error: Arguments must match pattern");
}
if( format.length == 1 && args.length == 0 ){
return String(format);
}
let formattedString = "";
// patterns
const decimalPattern = /%[0-9]{0,}d/;
const stringPattern = /%s/;
if( format.length == 0 ){
throw new Error("String format error: Invalid format");
}
let value = null;
let indexOfParam = 0;
let currPattern = null;
while( args.length > 0 ) {
currPattern = format[indexOfParam];
indexOfParam++;
if( currPattern.indexOf("%")<0 ){
formattedString+=currPattern;
continue;
}
value = args.shift(0,1);
if( decimalPattern.test(currPattern) ){
let numberLength = parseInt(currPattern.replace(/[^0-9]/g,''));
if( isNaN(numberLength) ){
numberLength = 0;
}
formattedString+=numberToLength(value, numberLength);
} else if( stringPattern.test(currPattern) ) {
if( typeof value === 'object' && value.toSource ){
formattedString+=String(value.toSource());
} else {
formattedString+=String(value);
}
} else {
throw new Error("String format error: Unrecognized pattern:"+currPattern);
}
}
return formattedString;
}
const numberToLength = (number, length) => {
length = parseInt(length);
number = String(number);
if( isNaN(length) || isNaN(parseInt(number)) ){
throw new Error("Invalid number passed");
}
while( number.length < length ) {
number = "0" + number;
}
return number;
}