โอเปอเรเตอร์ใดที่ใช้ในการส่งข้อยกเว้นจาวาสคริปต์ จาวาสคริปต์: ข้อยกเว้น การจัดการข้อยกเว้นและเงื่อนไข

โครงสร้าง try...catch ช่วยให้คุณตรวจสอบบล็อกของโค้ดเพื่อหาข้อผิดพลาด

JavaScript - การจับข้อผิดพลาด

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

บทช่วยสอนนี้จะสอนวิธีสกัดกั้นและจัดการข้อความแสดงข้อผิดพลาด JavaScript เพื่อที่คุณจะได้ไม่สูญเสียผู้ดู

ลอง ... จับโครงสร้าง

โครงสร้าง try ... catch ช่วยให้คุณตรวจสอบบล็อกของโค้ดเพื่อหาข้อผิดพลาด

บล็อก try มีโค้ดที่จะถูกดำเนินการและตรวจสอบ และ catch block มีโค้ดที่จะถูกดำเนินการหากเกิดข้อผิดพลาด

ไวยากรณ์
{
พยายาม
}
//รันโค้ดที่นี่
{
จับ(ผิดพลาด)
}

//เกิดข้อผิดพลาดในการจัดการที่นี่

โปรดทราบว่า try ... catch เขียนด้วยตัวพิมพ์เล็ก (ตัวอักษรเล็ก) การใช้อักษรตัวพิมพ์ใหญ่จะทำให้เกิดข้อผิดพลาด JavaScript!

ตัวอย่าง

ตัวอย่างด้านล่างควรแสดงป๊อปอัป "Welcome Guest!" เมื่อกดปุ่มเมาส์ อย่างไรก็ตาม มีการพิมพ์ผิดในฟังก์ชัน message() alert() พิมพ์เป็น addlert() เกิดข้อผิดพลาดของ JavaScript บล็อก catch จับข้อผิดพลาดและรันโค้ดเพิ่มเติมเพื่อจัดการ รหัสจะแสดงข้อความแสดงข้อผิดพลาดที่กำหนดเองเพื่อแจ้งให้ผู้ใช้ทราบว่าเกิดอะไรขึ้น:

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

ตัวอย่าง
var txt = "";
{
ข้อความฟังก์ชัน ()
{

}
พยายาม
{

จับ(ผิดพลาด)
{
ถ้า(!ยืนยัน(txt))
}
}
}

document.location.href="http://site/";

บางครั้ง ขณะรันโปรแกรม ข้อผิดพลาดเกิดขึ้นซึ่งยากจะคาดการณ์หรือคาดการณ์ได้ และบางครั้งก็เป็นไปไม่ได้ด้วยซ้ำ ตัวอย่างเช่น เมื่อถ่ายโอนไฟล์ผ่านเครือข่าย การเชื่อมต่อเครือข่ายอาจดรอปลงโดยไม่คาดคิด สถานการณ์ดังกล่าวเรียกว่าข้อยกเว้น ภาษา C# ช่วยให้นักพัฒนามีความสามารถในการจัดการสถานการณ์ดังกล่าว try...catch...finally build ใน C# ได้รับการออกแบบมาเพื่อสิ่งนี้

ลอง ( ) จับ ( ) ในที่สุด ( )

เมื่อใช้บล็อก try...catch..finally คำสั่งทั้งหมดในบล็อก try จะถูกดำเนินการก่อน หากไม่มีข้อยกเว้นเกิดขึ้นในบล็อกนี้ หลังจากดำเนินการแล้ว บล็อกสุดท้ายก็จะเริ่มดำเนินการ แล้วลอง..จับ..ก็เสร็จงานในที่สุด

หากเกิดข้อยกเว้นอย่างกะทันหันใน try block ลำดับการดำเนินการปกติจะหยุดลง และ CLR จะเริ่มค้นหา catch block ที่สามารถจัดการกับข้อยกเว้นได้ หากพบ catch block ที่ถูกต้อง มันจะถูกดำเนินการ และหลังจากเสร็จสิ้น บล็อกสุดท้ายก็จะถูกดำเนินการ

หากไม่พบ catch block ที่ต้องการ เมื่อมีข้อยกเว้นเกิดขึ้น โปรแกรมจะหยุดการดำเนินการอย่างผิดปกติ

ลองพิจารณาตัวอย่างต่อไปนี้:

โปรแกรมคลาส ( static void Main(string args) ( int x = 5; int y = x / 0; Console.WriteLine($"Result: (y)"); Console.WriteLine("End of program"); คอนโซลอ่าน ();

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

ในหน้าต่างนี้ เราจะเห็นว่ามีข้อยกเว้นเกิดขึ้น ซึ่งเป็นประเภท System.DivideByZeroException นั่นคือ ความพยายามที่จะหารด้วยศูนย์ เมื่อใช้รายการดูรายละเอียด คุณสามารถดูข้อมูลโดยละเอียดเพิ่มเติมเกี่ยวกับข้อยกเว้นได้

และในกรณีนี้ สิ่งเดียวที่เหลือสำหรับเราคือทำโปรแกรมให้เสร็จสิ้น

เพื่อหลีกเลี่ยงไม่ให้โปรแกรมล่ม คุณควรใช้ try...catch...finally build เพื่อจัดการกับข้อยกเว้น ดังนั้น ลองเขียนตัวอย่างใหม่ดังนี้:

โปรแกรมคลาส ( static void Main(string args) ( try ( int x = 5; int y = x / 0; Console.WriteLine($"Result: (y)"); ) catch ( Console.WriteLine("เกิดข้อยกเว้นขึ้น) ! "); ) ในที่สุด ( Console.WriteLine("Finally block"); ) Console.WriteLine("End of program"); Console.Read(); ) )

ในกรณีนี้ เราจะมีข้อยกเว้นอีกครั้งในบล็อก try เนื่องจากเราพยายามหารด้วยศูนย์ และถึงเส้นชัยแล้ว

อินท์ y = x / 0;

การทำงานของโปรแกรมจะหยุดลง CLR จะค้นหา catch block และถ่ายโอนการควบคุมไปยังบล็อกนั้น

หลังจาก catch block แล้ว บล็อกสุดท้ายก็จะถูกดำเนินการ

มีข้อยกเว้นเกิดขึ้น! ในที่สุดก็บล็อกจุดสิ้นสุดของโปรแกรม

ดังนั้น โปรแกรมจะยังคงไม่ทำการหารด้วยศูนย์ และจะไม่พิมพ์ผลลัพธ์ของการแบ่งนี้ แต่ตอนนี้จะไม่เกิดข้อผิดพลาด และข้อยกเว้นจะถูกจัดการใน catch block

ควรสังเกตว่าโครงสร้างนี้จำเป็นต้องมีบล็อกลอง ด้วย catch block เราสามารถละเว้นบล็อกสุดท้ายได้:

ลอง ( int x = 5; int y = x / 0; Console.WriteLine($"Result: (y)"); ) catch ( Console.WriteLine("Anข้อยกเว้นเกิดขึ้น!"); )

ในทางกลับกัน หากเรามีบล็อกในที่สุด เราก็สามารถละเว้นบล็อก catch และไม่จัดการกับข้อยกเว้น:

ลอง ( int x = 5; int y = x / 0; Console.WriteLine($"Result: (y)"); ) ในที่สุด ( Console.WriteLine("Finally Block"); )

อย่างไรก็ตาม แม้ว่าโครงสร้างดังกล่าวค่อนข้างถูกต้องจากมุมมองไวยากรณ์ C# แต่เนื่องจาก CLR ไม่พบ catch block ที่ต้องการ ข้อยกเว้นจะไม่ได้รับการจัดการและโปรแกรมจะหยุดทำงาน

การจัดการข้อยกเว้นและเงื่อนไข

นักพัฒนาสามารถคาดการณ์สถานการณ์พิเศษหลายประการได้ ตัวอย่างเช่น ให้โปรแกรมเกี่ยวข้องกับการป้อนตัวเลขและส่งออกกำลังสอง:

โมฆะคงที่หลัก (args สตริง) ( Console.WriteLine ("ป้อนตัวเลข"); int x = Int32.Parse (Console.ReadLine ()); x *= x; Console.WriteLine ("หมายเลขสี่เหลี่ยม: " + x) ; Console.Read();

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

โมฆะคงที่ Main(args สตริง) ( Console.WriteLine("Enter a number"); int x; string input = Console.ReadLine(); if (Int32.TryParse(input, out x)) ( x *= x; Console . WriteLine("หมายเลขสี่เหลี่ยม: " + x); else ( Console.WriteLine("Invalid input"); ) Console.Read();

เมธอด Int32.TryParse() จะคืนค่าเป็นจริงหากการแปลงสามารถทำได้ และคืนค่าเป็นเท็จหากไม่สามารถทำได้ หากการแปลงถูกต้อง ตัวแปร x จะมีตัวเลขที่ป้อน ดังนั้นหากไม่ใช้ try...catch คุณสามารถจัดการกับข้อยกเว้นที่เป็นไปได้ได้

จากมุมมองของประสิทธิภาพ การใช้ try..catch บล็อกมีราคาแพงกว่าการใช้เงื่อนไข ดังนั้น หากเป็นไปได้ แทนที่จะ try..catch ควรใช้โครงสร้างแบบมีเงื่อนไขเพื่อตรวจสอบสถานการณ์พิเศษแทน

ในภาษา T-SQL เช่นเดียวกับภาษาการเขียนโปรแกรมอื่นๆ เป็นไปได้ที่จะติดตามและสกัดกั้นข้อผิดพลาด วันนี้เราจะมาดูโครงสร้าง TRY CATCH ซึ่งเราสามารถจัดการกับสถานการณ์พิเศษได้ เช่น ข้อผิดพลาดที่ไม่คาดคิด

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

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

ดังนั้นในภาษา Transact-SQL จึงมีโครงสร้างพิเศษ TRY...CATCH ซึ่งปรากฏในเซิร์ฟเวอร์ SQL เวอร์ชันปี 2005 และใช้สำหรับการจัดการข้อผิดพลาด หากใครคุ้นเคยกับภาษาการเขียนโปรแกรมอื่น โครงสร้างนี้น่าจะคุ้นเคยกับคุณมากที่สุด เนื่องจากมีการใช้ในภาษาการเขียนโปรแกรมหลายภาษา

บันทึก! หากต้องการศึกษาภาษา T-SQL ให้ละเอียดยิ่งขึ้น ฉันแนะนำให้โปรแกรมเมอร์มือใหม่อ่านหนังสือ The T-SQL Programmer's Path บทช่วยสอนภาษา Transact-SQL

ลองสร้าง CATCH ใน T-SQL

TRY CATCH เป็นโครงสร้าง Transact-SQL สำหรับการจัดการข้อผิดพลาด ทุกสิ่งที่คุณต้องการตรวจสอบข้อผิดพลาด เช่น คุณวางรหัสที่อาจเกิดข้อผิดพลาดในบล็อก TRY จุดเริ่มต้นของบล็อกนี้ระบุด้วยคำสั่ง BEGIN TRY และจุดสิ้นสุดของบล็อกตามลำดับโดย END TRY

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

บล็อก CATCH นั้นไม่ได้ส่งข้อมูลใด ๆ เกี่ยวกับข้อผิดพลาดที่ตรวจพบไปยังแอปพลิเคชันที่เรียก ตัวอย่างเช่น หากคุณต้องการค้นหาหมายเลขหรือคำอธิบายของข้อผิดพลาด คุณสามารถใช้คำสั่ง SELECT, RAISERROR หรือ PRINT ใน จับบล็อก

จุดสำคัญเกี่ยวกับโครงสร้าง TRY CATCH ใน T-SQL

บล็อก CATCH จะต้องมาทันทีหลังจากบล็อก TRY ไม่อนุญาตให้วางคำแนะนำระหว่างบล็อกเหล่านี้
TRY CATCH จับข้อผิดพลาดทั้งหมดที่มีรหัสความรุนแรงมากกว่า 10 ที่ไม่ปิดการเชื่อมต่อฐานข้อมูล
ในโครงสร้าง TRY...CATCH คุณสามารถใช้ได้เพียงหนึ่งแพ็กเก็ตและหนึ่งบล็อกของคำสั่ง SQL เท่านั้น
โครงสร้าง TRY...CATCH สามารถซ้อนกันได้ ตัวอย่างเช่น ในบล็อก TRY อาจมีโครงสร้าง TRY...CATCH อื่นได้ หรือในบล็อก CATCH คุณสามารถเขียนตัวจัดการข้อผิดพลาดในกรณีที่เกิดข้อผิดพลาดในบล็อก CATCH เอง
คำสั่ง GOTO ไม่สามารถใช้เพื่อเข้าสู่บล็อก TRY หรือ CATCH ได้ แต่สามารถใช้เพื่อข้ามไปยังป้ายกำกับภายในบล็อก TRY หรือ CATCH เท่านั้น
ไม่สนับสนุนการจัดการข้อผิดพลาด TRY...CATCH ในฟังก์ชันที่ผู้ใช้กำหนด
โครงสร้าง TRY...CATCH ไม่จัดการกับข้อผิดพลาดต่อไปนี้: คำเตือนและข้อความแสดงข้อมูลที่มีระดับความรุนแรง 10 หรือต่ำกว่า การยกเลิกการเชื่อมต่อที่เกิดจากไคลเอ็นต์ และการยกเลิกผู้ดูแลระบบโดยใช้คำสั่ง KILL

ฟังก์ชั่นการรับข้อมูลข้อผิดพลาด

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

ERROR_NUMBER() – ส่งกลับหมายเลขข้อผิดพลาด;
ERROR_MESSAGE() - ส่งคืนคำอธิบายข้อผิดพลาด
ERROR_STATE() - ส่งคืนรหัสสถานะข้อผิดพลาด
ERROR_SEVERITY() - ส่งคืนระดับความรุนแรงของข้อผิดพลาด
ERROR_PROCEDURE() - ส่งคืนชื่อของขั้นตอนการจัดเก็บหรือทริกเกอร์ที่เกิดข้อผิดพลาด
ERROR_LINE() - ส่งกลับหมายเลขบรรทัดของคำสั่งที่ทำให้เกิดข้อผิดพลาด

ถ้าฟังก์ชันเหล่านี้ถูกเรียกนอกบล็อก CATCH ฟังก์ชันเหล่านี้จะคืนค่า NULL

ตัวอย่างของการใช้โครงสร้าง TRY...CATCH สำหรับการจัดการข้อผิดพลาด

เพื่อสาธิตวิธีการทำงานของโครงสร้าง TRY...CATCH ให้เขียนคำสั่ง SQL ง่ายๆ โดยที่เราตั้งใจสร้างข้อผิดพลาด เช่น การพยายามหารด้วยศูนย์

จุดเริ่มต้นของบล็อกการจัดการข้อผิดพลาด BEGIN TRY --คำแนะนำที่อาจเกิดข้อผิดพลาด DECLARE @TestVar1 INT = 10, @TestVar2 INT = 0, @Rez INT SET @Rez = @TestVar1 / @TestVar2 END TRY --จุดเริ่มต้นของบล็อก CATCH BEGIN CATCH - -การดำเนินการที่จะดำเนินการหากมีข้อผิดพลาดเกิดขึ้น SELECT ERROR_NUMBER() AS [หมายเลขข้อผิดพลาด], ERROR_MESSAGE() AS [คำอธิบายข้อผิดพลาด] SET @Rez = 0 END CATCH SELECT @Rez AS [ผลลัพธ์]

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

นั่นคือทั้งหมดสำหรับฉัน ฉันหวังว่าเนื้อหาจะเป็นประโยชน์กับคุณ ลาก่อน!

ในตัวอย่างนี้ เราได้พิมพ์โค้ดผิด (ใน try block )

ตัวอย่างควรแจ้งเตือน "Welcome guest!" แต่ alert สะกดผิด

catch block จับข้อผิดพลาดและรันโค้ดเพื่อจัดการ:

พยายาม (
addlert("ยินดีต้อนรับแขก!");
}
จับ(ผิดพลาด) (
document.getElementById("สาธิต").innerHTML = ผิดพลาด.ข้อความ;
}

ตัวอย่าง "ลองด้วยตัวเอง" เพิ่มเติมด้านล่าง

ความหมายและการใช้งาน

คำสั่ง try/catch/finally จะจัดการข้อผิดพลาดบางส่วนหรือทั้งหมดที่อาจเกิดขึ้นในบล็อกของโค้ดในขณะที่ยังคงรันโค้ดอยู่

ข้อผิดพลาดอาจเป็นข้อผิดพลาดในการเขียนโค้ดที่ทำโดยโปรแกรมเมอร์ ข้อผิดพลาดเนื่องจากการป้อนข้อมูลผิด และสิ่งที่ไม่อาจคาดเดาได้อื่นๆ

คำสั่ง try ช่วยให้คุณสามารถกำหนดบล็อกของโค้ดที่จะทดสอบหาข้อผิดพลาดในขณะที่กำลังดำเนินการ

คำสั่ง catch ช่วยให้คุณสามารถกำหนดบล็อกของโค้ดที่จะดำเนินการได้ หากมีข้อผิดพลาดเกิดขึ้นในบล็อกลอง

คำสั่งสุดท้ายช่วยให้คุณสามารถรันโค้ดได้หลังจากลองและจับ โดยไม่คำนึงถึงผลลัพธ์

หมายเหตุ: คำสั่ง catch และคำสั่งสุดท้ายเป็นทางเลือก แต่คุณจำเป็นต้องใช้คำสั่งใดคำสั่งหนึ่ง (หากไม่ใช่ทั้งสองอย่าง) ในขณะที่ใช้คำสั่ง try

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

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับข้อผิดพลาดของ JavaScript โปรดอ่านบทช่วยสอนเกี่ยวกับข้อผิดพลาดของ JavaScript

รองรับเบราว์เซอร์ คำแถลง

ลอง/จับ/ในที่สุด

ใช่

ไวยากรณ์

พยายาม (
tryCode - บล็อกของโค้ดที่จะลอง
}
จับ( ผิดพลาด) {
catchCode - บล็อกของโค้ดเพื่อจัดการข้อผิดพลาด
}
ในที่สุด(
ในที่สุดรหัส - บล็อกของโค้ดที่จะดำเนินการโดยไม่คำนึงถึงผลลัพธ์ของ try / catch
}

ค่าพารามิเตอร์ คำอธิบายพารามิเตอร์

ลองโค้ด	ที่จำเป็น. บล็อกของโค้ดที่จะทดสอบหาข้อผิดพลาดในขณะที่กำลังดำเนินการ
ผิดพลาด	จำเป็นหากใช้กับตัวจับ ระบุตัวแปรท้องถิ่นที่อ้างถึงข้อผิดพลาด ตัวแปรสามารถอ้างถึงอ็อบเจ็กต์ Error (ประกอบด้วยข้อมูลเกี่ยวกับข้อผิดพลาดที่เกิดขึ้น เช่น ข้อความ "ไม่ได้กำหนด addlert") หากข้อยกเว้นถูกสร้างขึ้นโดยคำสั่ง Throw ตัวแปรจะอ้างอิงถึงวัตถุที่ระบุในคำสั่ง Throw (ดู "ตัวอย่างเพิ่มเติม")
catchCode	ไม่จำเป็น. บล็อกของโค้ดที่จะดำเนินการ หากมีข้อผิดพลาดเกิดขึ้นในบล็อกลอง หากไม่มีข้อผิดพลาดเกิดขึ้น บล็อกของโค้ดนี้จะไม่ถูกดำเนินการ
ในที่สุดรหัส	ไม่จำเป็น. บล็อกของโค้ดที่จะดำเนินการโดยไม่คำนึงถึงผลการลอง / จับ

รายละเอียดทางเทคนิค เวอร์ชันจาวาสคริปต์:

ECMAScript3

ตัวอย่างเพิ่มเติม

ตัวอย่างนี้จะตรวจสอบอินพุต หากค่าไม่ถูกต้อง จะเกิดข้อยกเว้น (err)

ข้อยกเว้น (ข้อผิดพลาด) ถูกจับได้โดยคำสั่ง catch และข้อความแสดงข้อผิดพลาดแบบกำหนดเองจะปรากฏขึ้น:

กรุณากรอกตัวเลขระหว่าง 5 ถึง 10:

ทดสอบอินพุต

ฟังก์ชั่น myFunction() (
ข้อความ var, x;
ข้อความ = document.getElementById("ข้อความ");
message.innerHTML = "";
x = document.getElementById("สาธิต").value;
พยายาม (
if(x == "") โยน "ว่างเปล่า";
if(isNaN(x)) โยน "ไม่ใช่ตัวเลข";
ถ้า (x > 10) โยน "สูงเกินไป";
ถ้า(x< 5) throw "too low";
}
จับ(ผิดพลาด) (
message.innerHTML = "อินพุต" + ผิดพลาด;
}
}

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

ข้อผิดพลาดส่วนใหญ่มี 2 ประเภท - วากยสัมพันธ์และตรรกะ ข้อผิดพลาดทางวากยสัมพันธ์รวมถึงข้อผิดพลาดในชื่อของตัวแปร ฟังก์ชัน และข้อผิดพลาดในรูปแบบโค้ด โดยหลักการแล้ว ข้อผิดพลาดดังกล่าวสามารถตรวจพบได้ง่ายผ่านคอนโซลของเบราว์เซอร์

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

ลอง...จับโครงสร้างการจับข้อผิดพลาด

โครงสร้าง try..catch ประกอบด้วย 2 บล็อก: try แล้ว catch นี่คือตัวอย่างของรายการทั่วไป

ลอง ( // code... ) catch (ผิดพลาด) ( // การจัดการข้อผิดพลาด )

การออกแบบนี้มีลักษณะดังนี้:

รหัสภายในบล็อก try หรือที่เรียกว่ากับดักจะถูกดำเนินการ

หากไม่พบข้อผิดพลาด บล็อก catch(err) จะถูกละเว้น

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

ดังนั้นหากมีข้อผิดพลาดในการลอง สคริปต์จะไม่หยุดทำงาน และยิ่งกว่านั้น เรามีโอกาสที่จะจัดการกับข้อผิดพลาดภายใน catch block

ลองดูตัวอย่างนี้ด้วย