Cara menggunakan 0++ pada JavaScript

Apa cara yang disarankan untuk mengisi ulang nilai dalam JavaScript? Saya membayangkan saya bisa membangun fungsi khusus untuk menempatkan nol pada nilai yang diketikkan, tetapi saya bertanya-tanya apakah ada cara yang lebih langsung untuk melakukan ini?

Catatan: Dengan "zerofilled" yang saya maksudkan dalam arti kata database (di mana representasi 6 digit dari angka 5 adalah "000005").

Catatan untuk pembaca!

Seperti yang telah ditunjukkan oleh para komentator, solusi ini "pintar", dan seperti yang sering dilakukan oleh solusi cerdas, intensif ingatan dan relatif lambat. Jika kinerja menjadi perhatian Anda, jangan gunakan solusi ini!

Berpotensi ketinggalan zaman : ECMAScript 2017 menyertakan String.prototype.padStart dan Number.prototype.toLocaleString ada sejak ECMAScript 3.1. Contoh:

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

... akan menampilkan "-0000.10".

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

... akan menampilkan "-0000.1".

Yang Anda butuhkan hanyalah fungsi sederhana

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
}

Anda bisa memanggang ini ke perpustakaan jika Anda ingin menghemat namespace atau apa pun. Seperti dengan ekstensi jQuery .

Cara sederhana. Anda bisa menambahkan perkalian string untuk pad dan mengubahnya menjadi fungsi.

var pad = "000000";
var n = '5';
var result = (pad+n).slice(-pad.length);

Sebagai suatu fungsi,

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

Saya tidak percaya semua jawaban rumit di sini ... Gunakan saja ini:

var zerofilled = ('0000'+n).slice(-4);

Saya benar-benar harus datang dengan sesuatu seperti ini baru-baru ini. Saya pikir pasti ada cara untuk melakukannya tanpa menggunakan loop.

Inilah yang saya pikirkan.

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

Maka cukup gunakan itu memberikan angka ke nol pad:

> zeroPad(50,4);
"0050"

Jika angkanya lebih besar dari padding, angkanya akan meluas melampaui padding:

> zeroPad(51234, 3);
"51234"

Desimal juga baik-baik saja!

> zeroPad(51.1234, 4);
"0051.1234"

Jika Anda tidak keberatan mencemari namespace global, Anda dapat menambahkannya ke Number secara langsung:

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

Dan jika Anda lebih suka desimal, gunakan tempat di padding:

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

Bersulang!

XDR datang dengan variasi logaritmik yang tampaknya berkinerja lebih baik.

PERINGATAN : Fungsi ini gagal jika num sama dengan nol (mis. 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;
}

Berbicara tentang kinerja, ibu membandingkan 3 jawaban teratas ( 4 dengan variasi log ). Tebak mana yang majorly mengungguli dua lainnya? :)

Inilah yang saya gunakan untuk memasukkan angka hingga 7 karakter.

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

Pendekatan ini mungkin cukup bagi kebanyakan orang.

Sunting: Jika Anda ingin membuatnya lebih umum, Anda dapat melakukan ini:

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

Sunting 2: Perhatikan bahwa sejak ES2017 Anda dapat menggunakan String.prototype.padStart:

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

Browser modern sekarang mendukung padStart, Anda sekarang dapat melakukannya:

string.padStart(maxLength, "0");

Contoh:

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

Sayangnya, ada banyak saran rumit yang tidak perlu untuk masalah ini, biasanya melibatkan penulisan fungsi Anda sendiri untuk melakukan manipulasi matematika atau string atau memanggil utilitas pihak ketiga. Namun, ada cara standar untuk melakukan ini di pustaka JavaScript dasar hanya dengan satu baris kode. Mungkin pantas untuk membungkus satu baris kode ini dalam suatu fungsi untuk menghindari keharusan menentukan parameter yang tidak ingin Anda ubah seperti nama atau gaya lokal.

var amount = 5;

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

Ini akan menghasilkan nilai "005" untuk teks. Anda juga dapat menggunakan fungsi toLocaleString dari Angka untuk membuat angka nol di sebelah kanan titik desimal.

var amount = 5;

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

Ini akan menghasilkan nilai "5,00" untuk teks. Ubah useGrouping menjadi true untuk menggunakan pemisah koma untuk ribuan.

Perhatikan bahwa penggunaan toLocaleString()dengan localesdan optionsargumen distandarisasi secara terpisah dalam ECMA-402 , bukan dalam ECMAScript. Sampai hari ini, beberapa browser hanya menerapkan dukungan dasar , yaitu toLocaleString()dapat mengabaikan argumen apa pun.

Contoh Lengkap

Jika nomor pengisian diketahui sebelumnya tidak melebihi nilai tertentu, ada cara lain untuk melakukan ini tanpa loop:

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

Uji kasus di sini: http://jsfiddle.net/jfriend00/N87mZ/

Cara cepat dan kotor:

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

Untuk x = 5 dan hitung = 6 Anda akan memiliki y = "000005"

Inilah fungsi cepat yang saya buat untuk melakukan pekerjaan itu. Jika ada yang memiliki pendekatan yang lebih sederhana, silakan berbagi!

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

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

    return result;
}

Terlambat ke pesta di sini, tetapi saya sering menggunakan konstruk ini untuk melakukan ad-hoc padding dengan nilai tertentu n , yang dikenal sebagai positif, desimal:

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

Dimana offset 10 ^^ digit.

Misalnya Padding hingga 5 digit, di mana n = 123:

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

Versi hexidecimal dari ini sedikit lebih bertele-tele:

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

Catatan 1: Saya suka solusi @ profitehlolz juga, yang merupakan versi string ini, menggunakan fitur indeks negatif slice () yang bagus.

Saya benar-benar tidak tahu mengapa, tetapi tidak ada yang melakukannya dengan cara yang paling jelas. Ini implementasi saya.

Fungsi:

/** Pad a number with 0 on the left */
function zeroPad(number, digits) {
    var num = number+"";
    while(num.length < digits){
        num='0'+num;
    }
    return num;
}

Prototipe:

Number.prototype.zeroPad=function(digits){
    var num=this+"";
    while(num.length < digits){
        num='0'+num;
    }
    return(num);
};

Sangat mudah, saya tidak bisa melihat bagaimana ini bisa lebih sederhana. Untuk beberapa alasan, saya sudah sering melihat SO, orang-orang hanya berusaha menghindari 'untuk' dan 'sambil' mengulangi dengan cara apa pun. Menggunakan regex mungkin akan membutuhkan biaya lebih banyak siklus untuk padding 8 digit sepele seperti itu.

Saya menggunakan snipet ini untuk mendapatkan representasi 5 digit

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

Kekuatan Matematika!

x = integer ke pad
y = jumlah nol untuk pad

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

Saya tidak melihat ada yang menunjukkan fakta bahwa ketika Anda menggunakan String.prototype.substr () dengan angka negatif itu dihitung dari kanan.

Solusi satu liner untuk pertanyaan OP, representasi 6 digit dari nomor 5, adalah:

console.log(("00000000" + 5).substr(-6));

Generalisasi kita akan mendapatkan:

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

Setelah, lama, lama menguji 15 fungsi / metode berbeda yang ditemukan dalam jawaban pertanyaan ini, saya sekarang tahu mana yang terbaik (yang paling fleksibel dan tercepat).

Saya mengambil 15 fungsi / metode dari jawaban pertanyaan ini dan membuat skrip untuk mengukur waktu yang diperlukan untuk menjalankan 100 pembalut. Setiap pad akan pad nomor 9dengan 2000nol. Ini mungkin tampak berlebihan, dan memang begitu, tetapi memberi Anda ide bagus tentang penskalaan fungsi.

Kode yang saya gunakan dapat ditemukan di sini: https://gist.github.com/NextToNothing/6325915

Jangan ragu untuk memodifikasi dan menguji kode sendiri.

Untuk mendapatkan metode yang paling fleksibel, Anda harus menggunakan loop. Ini karena dengan jumlah yang sangat besar orang lain cenderung gagal, sedangkan, ini akan berhasil.

Jadi, loop mana yang digunakan? Nah, itu akan menjadi satu whilelingkaran. Sebuah forloop masih cepat, tetapi whileloop hanya sedikit lebih cepat (beberapa ms) - dan bersih.

Jawaban seperti itu oleh Wilco, Aleksandar Toplekatau Vitim.usakan melakukan pekerjaan dengan sempurna.

Secara pribadi, saya mencoba pendekatan yang berbeda. Saya mencoba menggunakan fungsi rekursif untuk mengisi string / angka. Itu bekerja lebih baik daripada metode bergabung dengan array tetapi, masih, tidak bekerja secepat loop for.

Fungsi saya adalah:

function pad(str, max, padder) {
  padder = typeof padder === "undefined" ? "0" : padder;
  return str.toString().length < max ? pad(padder.toString() + str, max, padder) : str;
}

Anda dapat menggunakan fungsi saya dengan, atau tanpa, mengatur variabel padding. Jadi seperti ini:

pad(1, 3); // Returns '001'
// - Or -
pad(1, 3, "x"); // Returns 'xx1'

Secara pribadi, setelah pengujian saya, saya akan menggunakan metode dengan loop sementara, seperti Aleksandar ToplekatauVitim.us . Namun, saya akan memodifikasinya sedikit sehingga Anda dapat mengatur string padding.

Jadi, saya akan menggunakan kode ini:

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'

Anda juga dapat menggunakannya sebagai fungsi prototipe, dengan menggunakan kode ini:

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'

Parameter pertama adalah bilangan real, parameter kedua adalah bilangan bulat positif yang menentukan jumlah minimum digit di sebelah kiri titik desimal dan parameter ketiga adalah bilangan bulat positif opsional yang menentukan angka jika digit di sebelah kanan titik desimal.

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
}

begitu

           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'

Jangan menemukan kembali roda, gunakan string garis bawah :

jsFiddle

var numToPad = '5';

alert(_.str.pad(numToPad, 6, '0')); // yields: '000005'

Ini adalah solusi ES6.

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

Di semua browser modern yang dapat Anda gunakan

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

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

Bukannya pertanyaan ini membutuhkan lebih banyak jawaban, tetapi saya pikir saya akan menambahkan versi sederhana ini.

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

Cara terbaru untuk melakukan ini jauh lebih sederhana:

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

output: "02"

Hanya solusi lain, tapi saya pikir ini lebih mudah dibaca.

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

Yang ini kurang asli, tetapi mungkin yang tercepat ...

zeroPad = function (num, count) {
    var pad = (num + '').length - count;
    while(--pad > -1) {
        num = '0' + num;
    }
    return num;
};

Solusi saya

Number.prototype.PadLeft = function (length, digit) {
    var str = '' + this;
    while (str.length < length) {
        str = (digit || '0') + str;
    }
    return str;
};

Pemakaian

var a = 567.25;
a.PadLeft(10); // 0000567.25

var b = 567.25;
b.PadLeft(20, '2'); // 22222222222222567.25

Mengapa tidak menggunakan rekursi?

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

Beberapa monkeypatching juga berfungsi

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

... dll.

Bersulang

Solusi paling sederhana dan paling mudah yang akan Anda temukan.

function zerofill(number,length) {
    var output = number.toString();
    while(output.length < length) {
      output = '0' + output;
    }
    return output;
}