Ответ 1

Я нашел это решение здесь, и это для меня намного проще:

var n = 123

String("00000" + n).slice(-5); // returns 00123
("00000" + n).slice(-5); // returns 00123
("     " + n).slice(-5); // returns "  123" (with two spaces)

И здесь я сделал расширение для строкового объекта:

String.prototype.paddingLeft = function (paddingValue) {
   return String(paddingValue + this).slice(-paddingValue.length);
};

Пример использования:

function getFormattedTime(date) {
  var hours = date.getHours();
  var minutes = date.getMinutes();

  hours = hours.toString().paddingLeft("00");
  minutes = minutes.toString().paddingLeft("00");

  return "{0}:{1}".format(hours, minutes);
};

String.prototype.format = function () {
    var args = arguments;
    return this.replace(/{(\d+)}/g, function (match, number) {
        return typeof args[number] != 'undefined' ? args[number] : match;
    });
};

Это вернет время в формате "15:30"

Ответ 2

Более быстрый метод

Если вы делаете это многократно, например, для ввода значений в массиве, а производительность является фактором, следующий подход может дать вам почти 100x преимущество в скорости (jsPerf) над другим решением, которое в настоящее время обсуждается на веб-сайтах. Основная идея заключается в том, что вы предоставляете функцию pad с полностью заполненной пустой строкой для использования в качестве буфера. Функция pad просто добавляется к строке, которая должна быть добавлена ​​к этой предварительно заполненной строке (одна строка concat), а затем разрезает или обрезает результат до нужной длины.

function pad(pad, str, padLeft) {
  if (typeof str === 'undefined') 
    return pad;
  if (padLeft) {
    return (pad + str).slice(-pad.length);
  } else {
    return (str + pad).substring(0, pad.length);
  }
}

Например, для ноль введите число до десяти цифр,

pad('0000000000',123,true);

Чтобы заполнить строку пробелом, так что вся строка - 255 символов,

var padding = Array(256).join(' '), // make a string of 255 spaces
pad(padding,123,true);

Тест производительности

См. тест jsPerf здесь.

И это быстрее, чем ES6 string.repeat на 2x, как показано в пересмотренном JsPerf здесь

Ответ 3

http://www.webtoolkit.info/javascript_pad.html

/**
*
*  Javascript string pad
*  http://www.webtoolkit.info/
*
**/

var STR_PAD_LEFT = 1;
var STR_PAD_RIGHT = 2;
var STR_PAD_BOTH = 3;

function pad(str, len, pad, dir) {

    if (typeof(len) == "undefined") { var len = 0; }
    if (typeof(pad) == "undefined") { var pad = ' '; }
    if (typeof(dir) == "undefined") { var dir = STR_PAD_RIGHT; }

    if (len + 1 >= str.length) {

        switch (dir){

            case STR_PAD_LEFT:
                str = Array(len + 1 - str.length).join(pad) + str;
            break;

            case STR_PAD_BOTH:
                var padlen = len - str.length;
                var right = Math.ceil( padlen / 2 );
                var left = padlen - right;
                str = Array(left+1).join(pad) + str + Array(right+1).join(pad);
            break;

            default:
                str = str + Array(len + 1 - str.length).join(pad);
            break;

        } // switch

    }

    return str;

}

Это намного более читабельно.

Ответ 4

Здесь рекурсивный подход к нему.

function pad(width, string, padding) { 
  return (width <= string.length) ? string : pad(width, padding + string, padding)
}

Пример...

pad(5, 'hi', '0')
=> "000hi"

Ответ 5

String.prototype.padStart() и String.prototype.padEnd() в настоящее время являются кандидатами на TC39: см. github.com/tc39/proposal-string-pad-start-end (доступно только в Firefox по состоянию на апрель 2016 года; polyfill доступен.)

Ответ 6

Используя метод ECMAScript 6 String # repeat, функция прокладок так же проста, как:

String.prototype.padLeft = function(char, length) { 
    return char.repeat(Math.max(0, length - this.length)) + this;
}

String#repeat в настоящее время поддерживается только в Firefox и Chrome. для другой реализации можно рассмотреть следующие простые polyfill:

String.prototype.repeat = String.prototype.repeat || function(n){ 
    return n<=1 ? this : (this + this.repeat(n-1)); 
}

Ответ 7

ECMAScript 2017 добавляет метод padStart к прототипу String. Этот метод будет заполнять строку пробелами до заданной длины. Этот метод также принимает необязательную строку, которая будет использоваться вместо пробелов для заполнения.

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

Также был добавлен метод padEnd, который работает одинаково.

Для совместимости браузеров (и полезного полинаполнения) см. Эту ссылку.

Ответ 8

Ключевым трюком в обоих этих решениях является создание экземпляра array с заданным размером (на одну больше требуемой длины), а затем для немедленного вызова метода join() для создания string. Метод join() передается прописью string (вероятно, пробелы). Поскольку array пуст, пустые ячейки будут отображаться как пустые strings в процессе соединения array в один результат string, и останется только отступы. Это действительно хорошая техника.

Ответ 9

Используя метод String # repeat и Arrow метода ECMAScript 6, функция pad очень проста:

var leftPad = (s, c, n) => c.repeat(n - s.length) + s;
leftPad("foo", "0", 5); //returns "00foo"

jsfiddle

редактировать: предложение из комментариев:

const leftPad = (s, c, n) => n - s.length > 0 ? c.repeat(n - s.length) + s : s;

таким образом, он не выдаст ошибку, если s.length больше, чем n

edit2: предложение из комментариев:

const leftPad = (s, c, n) =>{ s = s.toString(); c = c.toString(); return s.length > n ? s : c.repeat(n - s.length) + s; }

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

Ответ 10

панель со значениями по умолчанию

Я заметил, что мне в основном нужен padLeft для преобразования времени/заполнения номера

поэтому я написал эту функцию

function padL(a,b,c){//string/number,length=2,char=0
 return (new Array(b||2).join(c||0)+a).slice(-b)
}

Эта простая функция поддерживает Число или Строка как входной

default pad - 2 символа

default char 0

поэтому я могу просто написать

padL(1);
// 01

если я добавлю второй аргумент (ширина прокладки)

padL(1,3);
// 001

третий параметр (pad char)

padL('zzz',10,'x');
// xxxxxxxzzz

ИЗМЕНИТЬ @BananaAcid если вы передадите значение undefined или строку длины 0, вы получите 0undefined.. так:

как предложено

function padL(a,b,c){//string/number,length=2,char=0
 return (new Array((b||1)+1).join(c||0)+(a||'')).slice(-(b||2))
}

но это также может быть достигнуто короче.

function padL(a,b,c){//string/number,length=2,char=0
 return (new Array(b||2).join(c||0)+(a||c||0)).slice(-b)
}

работает также с:

padL(0)
padL(NaN)
padL('')
padL(undefined)
padL(false)

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

function pad(a,b,c,d){//string/number,length=2,char=0,0/false=Left-1/true=Right
return a=(a||c||0),c=new Array(b||2).join(c||0),d?(a+c).slice(0,b):(c+a).slice(-b)
}

который можно записать короче, не используя срез.

function pad(a,b,c,d){
 return a=(a||c||0)+'',b=new Array((++b||3)-a.length).join(c||0),d?a+b:b+a
}
/*

Usage:

pad(
 input // (int or string) or undefined,NaN,false,empty string
       // default:0 or PadCharacter
 // optional
 ,PadLength // (int) default:2
 ,PadCharacter // (string or int) default:'0'
 ,PadDirection // (bolean) default:0 (padLeft) - (true or 1) is padRight 
)

*/

теперь, если вы попытаетесь наложить "averylongword" на 2... это не моя проблема.

Сказал, что я даю вам совет.

В большинстве случаев, если вы набиваете, вы делаете это за одно значение N раз.

Использование любого типа функции внутри цикла замедляет цикл!!!

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

используйте что-то вроде этого:

var arrayOfNumbers=[1,2,3,4,5,6,7],
    paddedArray=[],
    len=arrayOfNumbers.length;
while(len--){
 paddedArray[len]=('0000'+arrayOfNumbers[len]).slice(-4);
}

если вы не знаете, как максимальный размер заполнения основывается на числах внутри массива.

var arrayOfNumbers=[1,2,3,4,5,6,7,49095],
    paddedArray=[],
    len=arrayOfNumbers.length;

// search the highest number
var arrayMax=Function.prototype.apply.bind(Math.max,null),
// get that string length
padSize=(arrayMax(arrayOfNumbers)+'').length,
// create a Padding string
padStr=new Array(padSize).join(0);
// and after you have all this static values cached start the loop.
while(len--){
 paddedArray[len]=(padStr+arrayOfNumbers[len]).slice(-padSize);//substr(-padSize)
}
console.log(paddedArray);

/*
0: "00001"
1: "00002"
2: "00003"
3: "00004"
4: "00005"
5: "00006"
6: "00007"
7: "49095"
*/

Ответ 11

С ES8 есть два варианта заполнения.

Вы можете проверить их в документации.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padEnd

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart

Ответ 12

Принимая идеи Сэмюэя, вверх здесь. И помните старый сценарий SQL, я попытался с этим:

a=1234;
'0000'.slice(a.toString().length)+a;

Он работает во всех случаях, которые я мог себе представить:

a=     1 result  0001
a=    12 result  0012
a=   123 result  0123
a=  1234 result  1234
a= 12345 result 12345
a=  '12' result  0012

Ответ 13

Вот простая функция, которую я использую.

var pad=function(num,field){
    var n = '' + num;
    var w = n.length;
    var l = field.length;
    var pad = w < l ? l-w : 0;
    return field.substr(0,pad) + n;
};

Например:

pad    (20,'     ');    //   20
pad   (321,'     ');    //  321
pad (12345,'     ');    //12345
pad (   15,'00000');    //00015
pad (  999,'*****');    //**999
pad ('cat','_____');    //__cat  

Ответ 14

Короткий путь:

(x=>(new Array(int-x.length+1)).join(char)+x)(String)

Пример:

(x=>(new Array(6-x.length+1)).join("0")+x)("1234")

return: "001234"

Ответ 15

строка дополнения добавлена в новую версию javascript.

str.padStart(targetLength [, padString])

https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/String/padStart

Если вы хотите, чтобы ваша собственная функция проверила этот пример:

const myString = 'Welcome to my house';
String.prototype.padLeft = function(times = 0, str = ' ') {
    return (Array(times).join(str) + this);
}
console.log(myString.padLeft(12, ':'));
//:::::::::::Welcome to my house

Ответ 16

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

• Поддержка многосимвольных пэдов.
• Не усекайте строку ввода
• По умолчанию по умолчанию пробел

Из моей библиотеки polyfill, но примените свою собственную должную осмотрительность для расширений прототипов.

// Tests
'hello'.lpad(4) === 'hello'
'hello'.rpad(4) === 'hello'
'hello'.lpad(10) === '     hello'
'hello'.rpad(10) === 'hello     '
'hello'.lpad(10, '1234') === '41234hello'
'hello'.rpad(10, '1234') === 'hello12341'

String.prototype.lpad || (String.prototype.lpad = function( length, pad )
{
    if( length < this.length ) return this;

    pad = pad || ' ';
    let str = this;

    while( str.length < length )
    {
        str = pad + str;
    }

    return str.substr( -length );
});

String.prototype.rpad || (String.prototype.rpad = function( length, pad )
{
    if( length < this.length ) return this;

    pad = pad || ' ';
    let str = this;

    while( str.length < length )
    {
        str += pad;
    }

    return str.substr( 0, length );
});

Ответ 17

Вот простой ответ в основном по одной строке кода.

var value = 35 // the numerical value
var x = 5 // the minimum length of the string

var padded = ("00000" + value).substr(-x);

Удостоверьтесь, что количество заполняемых вами символов, нулей здесь, не меньше, чем предполагаемая минимальная длина. Так что действительно, чтобы поставить его в одну строку, получить результат "00035" в этом случае:

var padded = ("00000" + 35).substr(-5);

Ответ 18

Массивные манипуляции очень медленны по сравнению с простой строкой concat. Конечно, ориентир для вашего случая использования.

function(string, length, pad_char, append) {
    string = string.toString();
    length = parseInt(length) || 1;
    pad_char = pad_char || ' ';

    while (string.length < length) {
        string = append ? string+pad_char : pad_char+string;
    }
    return string;
};

Ответ 19

Вариант ответа @Daniel LaFavers.

var mask = function (background, foreground) {
  bg = (new String(background));
  fg = (new String(foreground));
  bgl = bg.length;
  fgl = fg.length;
  bgs = bg.substring(0, Math.max(0, bgl - fgl));
  fgs = fg.substring(Math.max(0, fgl - bgl));
  return bgs + fgs;
};

Например:

mask('00000', 11  );   // '00011'
mask('00011','00' );   // '00000'
mask( 2     , 3   );   // '3'
mask('0'    ,'111');   // '1'
mask('fork' ,'***');   // 'f***'
mask('_____','dog');   // '__dog'

Ответ 20

Это 2014, и я предлагаю функцию заполнения строки Javascript. Ха!

Bare-bones: правая панель с пробелами

function pad ( str, length ) {
    var padding = ( new Array( Math.max( length - str.length + 1, 0 ) ) ).join( " " );
    return str + padding;
}

Необычный: панель с опциями

/**
 * @param {*}       str                         input string, or any other type (will be converted to string)
 * @param {number}  length                      desired length to pad the string to
 * @param {Object}  [opts]
 * @param {string}  [opts.padWith=" "]          char to use for padding
 * @param {boolean} [opts.padLeft=false]        whether to pad on the left
 * @param {boolean} [opts.collapseEmpty=false]  whether to return an empty string if the input was empty
 * @returns {string}
 */
function pad ( str, length, opts ) {
    var padding = ( new Array( Math.max( length - ( str + "" ).length + 1, 0 ) ) ).join( opts && opts.padWith || " " ),
        collapse = opts && opts.collapseEmpty && !( str + "" ).length;
    return collapse ? "" : opts && opts.padLeft ? padding + str : str + padding;
}

Использование (фантазия):

pad( "123", 5 );
// returns "123  "

pad( 123, 5 );
// returns "123  " - non-string input

pad( "123", 5, { padWith: "0", padLeft: true } );
// returns "00123"

pad( "", 5 );
// returns "     "

pad( "", 5, { collapseEmpty: true } );
// returns ""

pad( "1234567", 5 );
// returns "1234567"

Ответ 21

Если вы не возражаете, включая библиотеку служебных программ, библиотека lodash имеет _. pad, _.padLeft и _.padRight функции.

Ответ 22

Я думаю, что лучше избегать рекурсии, потому что это дорого.

function padLeft(str,size,padwith) {
	if(size <= str.length) {
        // not padding is required.
		return str;
	} else {
        // 1- take array of size equal to number of padding char + 1. suppose if string is 55 and we want 00055 it means we have 3 padding char so array size should be 3 + 1 (+1 will explain below)
        // 2- now join this array with provided padding char (padwith) or default one ('0'). so it will produce '000'
        // 3- now append '000' with orginal string (str = 55), will produce 00055

        // why +1 in size of array? 
        // it is a trick, that we are joining an array of empty element with '0' (in our case)
        // if we want to join items with '0' then we should have at least 2 items in the array to get joined (array with single item doesn't need to get joined).
        // <item>0<item>0<item>0<item> to get 3 zero we need 4 (3+1) items in array   
		return Array(size-str.length+1).join(padwith||'0')+str
	}
}

alert(padLeft("59",5) + "\n" +
     padLeft("659",5) + "\n" +
     padLeft("5919",5) + "\n" +
     padLeft("59879",5) + "\n" +
     padLeft("5437899",5));

Ответ 23

/**************************************************************************************************
Pad a string to pad_length fillig it with pad_char.
By default the function performs a left pad, unless pad_right is set to true.

If the value of pad_length is negative, less than, or equal to the length of the input string, no padding takes place.
**************************************************************************************************/
if(!String.prototype.pad)
String.prototype.pad = function(pad_char, pad_length, pad_right) 
{
   var result = this;
   if( (typeof pad_char === 'string') && (pad_char.length === 1) && (pad_length > this.length) )
   {
      var padding = new Array(pad_length - this.length + 1).join(pad_char); //thanks to http://stackoverflow.com/questions/202605/repeat-string-javascript/2433358#2433358
      result = (pad_right ? result + padding : padding + result);
   }
   return result;
}

И тогда вы можете сделать:

alert( "3".pad("0", 3) ); //shows "003"
alert( "hi".pad(" ", 3) ); //shows " hi"
alert( "hi".pad(" ", 3, true) ); //shows "hi "

Ответ 24

Вот функция JavaScript, которая добавляет указанное количество прокладок с пользовательским символом. функция принимает три параметра.

    padMe --> string or number to left pad
    pads  --> number of pads
    padSymble --> custom symble, default is "0" 

    function leftPad(padMe, pads, padSymble) {
         if( typeof padMe === "undefined") {
             padMe = "";
         }
         if (typeof pads === "undefined") {
             pads = 0;
         }
         if (typeof padSymble === "undefined") {
             padSymble = "0";
         }

         var symble = "";
         var result = [];
         for(var i=0; i < pads ; i++) {
            symble += padSymble;
         }
        var length = symble.length - padMe.toString().length;
        result = symble.substring(0, length);
        return result.concat(padMe.toString());
    }

/* Here are some results:

> leftPad(1)
"1"
> leftPad(1, 4)
"0001"
> leftPad(1, 4, "0")
"0001"
> leftPad(1, 4, "@")
"@@@1"

*/

Ответ 25

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

Пример: заполнение строки в e пробелом до 25 символов.

var e = "hello"; e = e + "                         ".substring(e.length)

Результат: "hello "

Если вы хотите сделать то же самое с номером, как ввод, просто вызовите .toString() на нем раньше.

Ответ 26

еще одно взятие с комбинацией решений пары

/**
 * pad string on left
 * @param {number} number of digits to pad, default is 2
 * @param {string} string to use for padding, default is '0' *
 * @returns {string} padded string
 */
String.prototype.paddingLeft = function (b,c) {
    if (this.length > (b||2))
        return this+'';
  return (this||c||0)+'',b=new Array((++b||3)-this.length).join(c||0),b+this
};

/**
 * pad string on right
 * @param {number} number of digits to pad, default is 2
 * @param {string} string to use for padding, default is '0' *
 * @returns {string} padded string
 */
String.prototype.paddingRight = function (b,c) {
  if (this.length > (b||2))
        return this+'';
  return (this||c||0)+'',b=new Array((++b||3)-this.length).join(c||0),this+b
};    

Ответ 27

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

function l(p,t,v){
    v+="";return v.length>=t?v:l(p,t,p+v); 
}

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

function padLeft(pad, totalLength, value){
    value = value.toString();

    if( value.length >= totalLength ){
        return value;
    }else{
        return padLeft(pad, totalLength, pad + value);
    }
}

Пример, который мы использовали, состоял в том, чтобы обеспечить, чтобы числа были дополнены с помощью 0 влево, чтобы сделать максимальную длину 6. Вот пример:

function l(p,t,v){v+="";return v.length>=t?v:l(p,t,p+v);}

var vals = [6451,123,466750];

var pad = l(0,6,vals[0]);// pad with 0's, max length 6

var pads = vals.map(function(i){ return l(0,6,i) });

document.write(pads.join("<br />"));

Ответ 28

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

// include the module in your script, there is no need to export
var jsAddOns = require('<path to module>/jsAddOns');

~~~~~~~~~~~~ jsAddOns.js ~~~~~~~~~~~~

/* 
 * method prototype for any Object to pad it toString()
 * representation with additional characters to the specified length
 *
 * @param padToLength required int
 *     entire length of padded string (original + padding)
 * @param padChar optional char
 *     character to use for padding, default is white space
 * @param padLeft optional boolean
 *     if true padding added to left
 *     if omitted or false, padding added to right
 *
 * @return padded string or
 *     original string if length is >= padToLength
 */
Object.prototype.pad = function(padToLength, padChar, padLeft) {    

    // get the string value
    s = this.toString()

    // default padToLength to 0
    // if omitted, original string is returned
    padToLength = padToLength || 0;

    // default padChar to empty space
    padChar = padChar || ' ';


    // ignore padding if string too long
    if (s.length >= padToLength) {
        return s;
    }

    // create the pad of appropriate length
    var pad = Array(padToLength - s.length).join(padChar);

    // add pad to right or left side
    if (padLeft) {
        return pad  + s;        
    } else {
        return s + pad;
    }
};

Ответ 29

• Никогда не вставляйте данные где-нибудь (особенно не в начале, например str = pad + str;), так как данные будут перераспределены каждый раз. Добавляйте всегда в конец!
• Не вставляйте свою строку в цикл. Оставьте это в покое и сначала создайте свою панель. В конце концов соедините его с основной строкой.
• Не назначайте строку прокладки каждый раз (например, str += pad;). Гораздо быстрее добавить строку дополнений к себе и извлечь первые x-символы (синтаксический анализатор может сделать это эффективно, если вы извлечете из первого char). Это экспоненциальный рост, а это означает, что он временно отнимает некоторую память (вы не должны делать этого с чрезвычайно большими текстами).

if (!String.prototype.lpad) {
    String.prototype.lpad = function(pad, len) {
        while (pad.length < len) {
            pad += pad;
        }
        return pad.substr(0, len-this.length) + this;
    }
}

if (!String.prototype.rpad) {
    String.prototype.rpad = function(pad, len) {
        while (pad.length < len) {
            pad += pad;
        }
        return this + pad.substr(0, len-this.length);
    }
}

Ответ 30

используя padStart

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

https://developer.mozilla.org/docs/Web/JavaScript/Referencia/Objetos_globales/String/padStart