การประมวลผลแบบเรียกซ้ำของการพิจารณาเวลาเริ่มต้นและสิ้นสุดในการตรวจสอบความถูกต้องของแบบฟอร์ม

ในโครงการล่าสุด จำเป็นต้องมีการตรวจสอบความถูกต้องของแบบฟอร์มโดยพิจารณาช่วงเวลาเริ่มต้นและสิ้นสุด: เวลาสิ้นสุดจะต้องมากกว่าหรือเท่ากับเวลาเริ่มต้น นั่นคือ: ปีที่สิ้นสุดจะต้องมากกว่าปีที่เริ่มต้น หากเท่ากัน ให้เปรียบเทียบเดือนเริ่มต้นและเดือนสิ้นสุด หากเดือนเริ่มต้นและเดือนสิ้นสุดเท่ากัน ให้เปรียบเทียบวันที่ จากนั้น สำหรับการตรวจสอบแต่ละครั้ง คุณสามารถใช้ฟังก์ชันต่อไปนี้เพื่อเปรียบเทียบได้

ฟังก์ชั่นเปรียบเทียบ (เริ่มต้น สิ้นสุด ข้อผิดพลาด){
var start = parseInt(เริ่ม,10);
var end = parseInt(สิ้นสุด,10);
var diff = สิ้นสุด - เริ่มต้น;
ถ้า (ความแตกต่าง < 0) {
การแจ้งเตือน (ข้อผิดพลาด);
}อื่น{
กลับเป็นจริง;
-
-

ด้วยวิธีนี้ ในระหว่างการตรวจสอบ ตราบใดที่ผลลัพธ์กลับมาเป็นความจริง แสดงว่าผ่านแล้ว ชอบ:

var year = เปรียบเทียบ(2544,2546,'ปี');
var month = เปรียบเทียบ(1,2,'เดือน');
var day = เปรียบเทียบ (12,13, 'วัน');
alert(ปี && เดือน && วัน); //ผลลัพธ์เป็นจริง------"จริง"

แก้ไขเดือนเริ่มต้นและสิ้นสุดและวันที่เริ่มต้นและสิ้นสุดด้านบน ชอบ:

var year = เปรียบเทียบ(2544,2546,'ปี');
var month = เปรียบเทียบ(3,2,'เดือน');
var day = เปรียบเทียบ (24,13, 'วัน');
alert(ปี && เดือน && วัน); /ผลลัพธ์เป็นเท็จ------"เท็จ"

ผลลัพธ์การดำเนินการจะแสดง "เดือน" "วัน" และ "เท็จ" ตามลำดับ เมื่อเดือนเริ่มต้นและเดือนสิ้นสุดไม่ถูกต้อง เราไม่จำเป็นต้องตรวจสอบวันที่ แต่ข้อกำหนดเบื้องต้นสำหรับการตรวจสอบเดือนคือการตรวจสอบปี ผ่านข้อกำหนดเบื้องต้นสำหรับการตรวจสอบวัน เดือนได้รับการตรวจสอบแล้ว หลังจากการวิเคราะห์อย่างรอบคอบ ฉันตัดสินใจจัดเก็บพารามิเตอร์ทั้งสามของฟังก์ชันด้านบนไว้ในโหมดซิงเกิลตัน กล่าวคือ:

-
เริ่มต้น:2001,
สิ้นสุด:2546,
ข้อผิดพลาด: "ปีที่สิ้นสุดต้องมากกว่าปีที่เริ่มต้น"
-

อย่างไรก็ตาม ฉันไม่ต้องการกำหนดพารามิเตอร์ของฟังก์ชัน ฟังก์ชันสามารถตรวจสอบโดยอัตโนมัติตามพารามิเตอร์ที่ส่งผ่านได้หรือไม่ คำตอบคือใช่ ที่จุดเริ่มต้นของฟังก์ชัน ให้กำหนดจำนวนพารามิเตอร์ก่อน หากมีค่ามากกว่า 1 แสดงว่ามีการประมวลผลแบบเรียกซ้ำ การประมวลผลแบบเรียกซ้ำทำอย่างไร? ฉันทำสิ่งต่อไปนี้ภายในฟังก์ชัน:

var len = arguments.length;
ถ้า (เลน > 1){
var args = Array.prototype.slice.call (อาร์กิวเมนต์);
args.shift(); //ลบพารามิเตอร์แรกออกและใช้พารามิเตอร์ที่เหลือสำหรับการประมวลผลแบบเรียกซ้ำ
-

สำหรับอาร์กิวเมนต์ เราไม่สามารถเรียกใช้เมธอด Array.shift() ได้โดยตรง แม้ว่าอาร์กิวเมนต์จะมีแอตทริบิวต์ความยาว แต่ก็ไม่ใช่อาร์เรย์ ดังนั้นให้ใช้เมธอด Array.slice() เพื่อแปลงเป็นอาร์เรย์ ในส่วนของข้อโต้แย้ง คุณสามารถเรียนรู้ข้อมูลเพิ่มเติมทางออนไลน์ได้ และจะไม่ลงรายละเอียดที่นี่ เหตุใดจึงประมวลผลเฉพาะเมื่อ len มากกว่า 1 เนื่องจากเมื่อพารามิเตอร์เป็น 1 ไม่จำเป็นต้องดำเนินการยืนยันขั้นตอนถัดไป การประมวลผลแบบเรียกซ้ำเกิดขึ้นเมื่อใด หากคุณคิดอย่างรอบคอบ จำเป็นเฉพาะเมื่อค่าเริ่มต้นและมูลค่าสิ้นสุดเท่ากัน เมื่อเข้าใจสิ่งนี้ เราจึงสามารถสร้างฟังก์ชันการตรวจสอบของเราได้อย่างง่ายดาย

var diff = parseInt(อาร์กิวเมนต์[0].end,10) - parseInt(อาร์กิวเมนต์[0].begin,10);
ถ้า (ส่วนต่าง <0 ){
การแจ้งเตือน (อาร์กิวเมนต์ [0] .error);
กลับเท็จ;
} อื่น ๆ if(diff == 0){
กลับ len > 1 ? arguments.callee.apply(this,args) : true;
}อื่น{
กลับเป็นจริง;
-

ในโค้ดข้างต้น arguments.callee เป็นฟังก์ชันเกี่ยวกับการใช้งาน คุณสามารถค้นหาข้อมูลที่เกี่ยวข้องได้บนเว็บ

ณ จุดนี้ ฟังก์ชั่นการตรวจสอบเสร็จสมบูรณ์แล้ว แต่คุณต้องใส่ใจกับสิ่งต่อไปนี้:

1. แม้ว่าไม่ได้กำหนดจำนวนพารามิเตอร์ แต่ลำดับของพารามิเตอร์ยังคงมีความสำคัญ เนื่องจากผลการตรวจสอบของพารามิเตอร์ก่อนหน้าจะกำหนดว่าการตรวจสอบพารามิเตอร์ถัดไปจะดำเนินต่อไปหรือไม่
2. อย่าละเลยพารามิเตอร์ตัวที่สอง 10 ของฟังก์ชัน parseInt() หากละเว้น เมื่อพบค่าที่ขึ้นต้นด้วย 0 (เช่น 07, 08) จะถูกประมวลผลเป็นฐานแปด

ในตอนนี้ เรามาดู ตัวอย่างกัน ดีกว่า บางครั้งเราไม่ต้องการแสดงข้อมูลข้อผิดพลาดในรูปแบบของการแจ้งเตือน เราสามารถปรับแต่งฟังก์ชันการประมวลผลและส่งต่อไปเป็นพารามิเตอร์สุดท้ายได้ จากนั้นที่จุดเริ่มต้นของฟังก์ชัน รับฟังก์ชันการประมวลผล เช่น:

var func = ข้อโต้แย้ง [len - 1];
ถ้า (ประเภทของ func == 'ฟังก์ชั่น') {
func (อาร์กิวเมนต์ [0]);
-

ดังนั้นฟังก์ชันการประมวลผลขั้นสุดท้ายจึงเป็นดังนี้:

ฟังก์ชั่นเปรียบเทียบ () {
var len = arguments.length;
var func = ข้อโต้แย้ง [len - 1];
ถ้า (เลน > 1){
var args = Array.prototype.slice.call (อาร์กิวเมนต์);
args.shift(); //ลบพารามิเตอร์แรกออกและใช้พารามิเตอร์ที่เหลือสำหรับการประมวลผลแบบเรียกซ้ำ
-
var diff = parseInt(อาร์กิวเมนต์[0].end,10) - parseInt(อาร์กิวเมนต์[0].begin,10);
ถ้า (ส่วนต่าง <0 ){
(typeof func == 'ฟังก์ชั่น') ? func(arguments[0].error) : alert(arguments[0].error);
กลับเท็จ;
} อื่น ๆ if(diff == 0){
กลับ len > 1 ? arguments.callee.apply(this,args) : true;
}อื่น{
กลับเป็นจริง;
-
-

ฟังก์ชั่นเปรียบเทียบ () {
var len = arguments.length;
ถ้า (เลน > 1){
var args = Array.prototype.slice.call (อาร์กิวเมนต์);
args.shift(); //ลบพารามิเตอร์แรกออกและใช้พารามิเตอร์ที่เหลือสำหรับการประมวลผลแบบเรียกซ้ำ

-
var diff = parseInt(อาร์กิวเมนต์[0].end,10) - parseInt(อาร์กิวเมนต์[0].begin,10);
ถ้า (ส่วนต่าง <0 ){
การแจ้งเตือน (อาร์กิวเมนต์ [0] .error);
กลับเท็จ;
} อื่น ๆ if(diff == 0){
กลับ len > 1 ? arguments.callee.apply(this,args) : true;
}อื่น{
กลับเป็นจริง;
-
-