Pemrosesan rekursif penilaian waktu mulai dan akhir dalam validasi formulir

Dalam proyek baru-baru ini, validasi formulir memerlukan penilaian rentang waktu mulai dan berakhir: waktu berakhir harus lebih besar atau sama dengan waktu mulai. Artinya: tahun akhir harus lebih besar dari tahun awal; jika sama, bandingkan bulan awal dan bulan akhir; jika bulan awal dan bulan akhir juga sama, bandingkan tanggalnya; Kemudian, untuk setiap verifikasi, Anda dapat menggunakan fungsi berikut untuk membandingkan.

perbandingan fungsi(mulai,akhir,kesalahan){
var mulai = parseInt(mulai,10);
var akhir = parseInt(akhir,10);
var diff = akhir - mulai;
jika(perbedaan < 0){
peringatan(kesalahan);
}kalau tidak{
kembali benar;
}
}

Dengan cara ini, pada saat verifikasi, selama hasilnya benar, berarti lolos. menyukai:

var tahun = bandingkan(2001,2003,'tahun');
var bulan = bandingkan(1,2,'bulan');
var hari = bandingkan(12,13,'hari');
alert(tahun && bulan && hari); //Hasilnya benar------"benar"

Ubah bulan awal dan akhir serta tanggal mulai dan berakhir di atas. menyukai:

var tahun = bandingkan(2001,2003,'tahun');
var bulan = bandingkan(3,2,'bulan');
var hari = bandingkan(24,13,'hari');
alert(tahun && bulan && hari); /Hasilnya salah------"salah"

Hasil eksekusi menampilkan "bulan", "hari", dan "salah" secara berurutan, jika bulan awal dan akhir salah, kita tidak perlu memverifikasi tanggal, prasyarat verifikasi bulan adalah verifikasi tahun lolos; prasyarat untuk verifikasi hari Bulan diverifikasi. Setelah menganalisa secara cermat, saya memutuskan untuk menyimpan ketiga parameter fungsi di atas dalam mode singleton, yaitu:

{
mulai:2001,
akhir:2003,
error: "Tahun akhir harus lebih besar dari tahun awal"
}

Namun, saya tidak ingin menentukan parameter fungsi. Bisakah fungsi memverifikasi secara otomatis berdasarkan parameter yang diteruskan? Jawabannya adalah ya. Di awal fungsi, tentukan dulu jumlah parameternya. Jika lebih besar dari 1, maka berisi pemrosesan rekursif. Bagaimana cara melakukan pemrosesan rekursif? Saya melakukan hal berikut di dalam fungsi:

var len = argumen.panjang;
jika(len > 1){
var args = Array.prototype.slice.call(argumen);
args.shift(); //Hapus parameter pertama dan gunakan parameter lainnya untuk pemrosesan rekursif
}

Untuk argumen, kita tidak bisa memanggil metode Array.shift() secara langsung. Meskipun argumen memiliki atribut panjang, argumen tersebut bukanlah array, jadi gunakan metode Array.slice() untuk mengubahnya menjadi array. Mengenai argumen, Anda dapat mempelajari informasi lebih lanjut secara online dan tidak akan membahas detailnya di sini. Mengapa hanya diproses ketika len lebih besar dari 1? Karena bila parameternya 1 maka tidak perlu melakukan langkah verifikasi selanjutnya. Kapan pemrosesan rekursif terjadi? Jika dipikir-pikir dengan hati-hati, ini hanya diperlukan ketika nilai awal dan nilai akhir sama. Dengan memahami hal ini, kita dapat dengan mudah membangun fungsi verifikasi kita.

var diff = parseInt(argumen[0].end,10) - parseInt(argumen[0].begin,10);
jika(perbedaan <0 ){
peringatan(argumen[0].kesalahan);
kembali salah;
}lainnya jika(beda == 0){
kembali len > 1 ?argumen.callee.apply(ini,args) : benar;
}kalau tidak{
kembali benar;
}

Dalam kode di atas, argument.callee adalah fungsi itu sendiri. Mengenai penggunaan apply, Anda dapat menemukan informasi yang relevan di web.

Sampai disini fungsi verifikasi sudah selesai, namun perlu memperhatikan hal-hal berikut ini:

1. Walaupun jumlah parameter tidak ditentukan, namun urutan parameter tetap penting, karena hasil verifikasi parameter sebelumnya menentukan apakah verifikasi parameter berikutnya dilanjutkan;
2. Jangan abaikan parameter kedua 10 dari fungsi parseInt(). Jika diabaikan, saat menemukan nilai yang dimulai dengan 0 (misalnya 07, 08), maka akan diproses dalam oktal.

Itu saja untuk saat ini, mari kita lihat contohnya . Terkadang, kita tidak ingin menampilkan informasi kesalahan dalam bentuk peringatan. Kita dapat menyesuaikan fungsi pemrosesan dan meneruskannya sebagai parameter terakhir. Kemudian di awal fungsi, dapatkan fungsi pemrosesan, seperti:

var func = argumen[len - 1];
if(typeof func == 'fungsi'){
func(argumen[0]);
}

Jadi, fungsi pemrosesan akhirnya adalah seperti ini:

fungsi membandingkan(){
var len = argumen.panjang;
var func = argumen[len - 1];
jika(len > 1){
var args = Array.prototype.slice.call(argumen);
args.shift(); //Hapus parameter pertama dan gunakan parameter lainnya untuk pemrosesan rekursif
}
var diff = parseInt(argumen[0].end,10) - parseInt(argumen[0].begin,10);
jika(perbedaan <0 ){
(typeof func == 'fungsi') ? func(argumen[0].kesalahan) : peringatan(argumen[0].kesalahan);
kembali salah;
}lainnya jika(beda == 0){
kembali len > 1 ?argumen.callee.apply(ini,args) : benar;
}kalau tidak{
kembali benar;
}
}

fungsi membandingkan(){
var len = argumen.panjang;
jika(len > 1){
var args = Array.prototype.slice.call(argumen);
args.shift(); //Hapus parameter pertama dan gunakan parameter lainnya untuk pemrosesan rekursif

}
var diff = parseInt(argumen[0].end,10) - parseInt(argumen[0].begin,10);
jika(perbedaan <0 ){
peringatan(argumen[0].kesalahan);
kembali salah;
}lainnya jika(beda == 0){
kembali len > 1 ?argumen.callee.apply(ini,args) : benar;
}kalau tidak{
kembali benar;
}
}