การจัดการข้อผิดพลาดแบบอะซิงโครนัส
พัฒนากลยุทธ์การจัดการข้อผิดพลาดที่มีประสิทธิภาพสำหรับการดำเนินการแบบอะซิงโครนัส เพื่อให้แอปจัดการความล้มเหลวของเครือข่ายและข้อยกเว้นได้อย่างเหมาะสม
การจัดการข้อผิดพลาดแบบอะซิงโครนัส เป็นบทเรียน Flutter Mobile Development ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Flutter Mobile Development และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Flutter Mobile Development มีบทเรียนทั้งหมด 4 บทเรียน
บางส่วนของบทเรียนนี้ยังไม่ได้รับการแปล และแสดงเป็นภาษาอังกฤษ
Handling Unpredictable Async Errors
Asynchronous operations, like fetching data from the internet or reading files, are inherently unpredictable. They might succeed, fail, or even time out.
Robust error handling is crucial to prevent your app from crashing and to provide a smooth user experience. It allows you to gracefully manage these failures.
`try-catch` for Async Operations
The familiar try-catch block in Dart is your primary tool for handling exceptions in asynchronous code. When an await expression throws an error, it can be caught by an enclosing try-catch block.
try: Contains the code that might throw an exception.catch: Catches and handles the exception if one occurs.on: (Optional) Catches specific types of exceptions.
Catching a Simulated Error
Let's see try-catch in action. This example simulates a network error by throwing an Exception within an async function. Notice how catch handles it.
import 'dart:async';
Future<String> fetchData() async {
await Future.delayed(Duration(seconds: 1));
// Simulate a network error
throw Exception("Failed to fetch data!");
return "Data received"; // This line won't be reached
}
void main() async {
print("Starting data fetch...");
try {
String data = await fetchData();
print("Success: $data");
} catch (e) {
print("Error caught: $e");
} finally {
print("Fetch attempt complete.");
}
}Handling Specific Exception Types
Sometimes, you want to handle different types of errors in different ways. The on keyword allows you to catch specific exception types, making your error handling more precise.
For example, you might handle a SocketException (network issue) differently from a generic Exception.
Targeted Error Handling
Here, we define two types of errors: a custom NetworkException and a generic Exception. The on clause lets us provide specific handling for each.
import 'dart:async';
class NetworkException implements Exception {
final String message;
NetworkException(this.message);
@override
String toString() => 'NetworkException: $message';
}
Future<void> performNetworkCall(bool shouldFailNetwork) async {
await Future.delayed(Duration(milliseconds: 500));
if (shouldFailNetwork) {
throw NetworkException("No internet connection!");
} else {
throw Exception("An unknown error occurred.");
}
}
void main() async {
print("Attempt 1: Simulate network failure");
try {
await performNetworkCall(true);
} on NetworkException catch (e) {
print("Caught specific network error: ${e.message}");
} catch (e) {
print("Caught generic error: $e");
}
print("\nAttempt 2: Simulate unknown error");
try {
await performNetworkCall(false);
} on NetworkException catch (e) {
print("Caught specific network error: ${e.message}");
} catch (e) {
print("Caught generic error: $e");
}
}Ensuring Cleanup with `finally`
The finally block is an optional part of a try-catch statement. Code inside this block will always execute, regardless of whether an exception was thrown or caught.
It's perfect for cleanup operations, like closing a file stream or dismissing a loading indicator, ensuring resources are properly managed.
Alternative: `Future.catchError`
While try-catch works well with async/await, you can also handle errors directly on a Future object using its .catchError() method. This is often used when chaining Futures or when not using await immediately.
It takes a function that will be called if the Future completes with an error.
Handling Errors with `catchError`
Here's how .catchError() can be used. Notice that the error is handled as part of the Future's completion chain, without needing an async function or await for the error handling itself.
import 'dart:async';
Future<String> getUserData() {
return Future.delayed(Duration(seconds: 1)).then((_) {
throw Exception("User data not found!");
return "User data"; // Unreachable
});
}
void main() {
print("Fetching user data...");
getUserData().then((data) {
print("Success: $data");
}).catchError((error) {
print("Error with .catchError(): $error");
}).whenComplete(() {
print("User data fetch completed.");
});
}Good Practices for Error Handling
Effective error handling makes your app robust and user-friendly:
- Log errors: Use a logging framework to record errors for debugging.
- Provide feedback: Inform the user about what went wrong (e.g., "Network unavailable").
- Retry mechanism: For transient network issues, consider offering a retry option.
- Avoid empty
catchblocks: Always handle or re-throw errors, don't just swallow them.
Async Error Handling Check
Consider the following Dart code snippet. Which statements about its error handling are true?
import 'dart:async';
Future<String> riskyOperation() async {
await Future.delayed(Duration(milliseconds: 100));
if (DateTime.now().second % 2 == 0) {
throw FormatException("Invalid data format!");
}
return "Data processed.";
}
void main() async {
try {
String result = await riskyOperation();
print("Result: $result");
} on FormatException catch (e) {
print("Specific error: ${e.message}");
} catch (e) {
print("Generic error: $e");
} finally {
print("Operation finished.");
}
}Recap: Mastering Async Errors
In this lesson, we explored how to handle errors in asynchronous Dart and Flutter applications. You learned:
- The importance of robust error handling.
- Using
try-catchwithasync/await. - Catching specific exceptions with
on. - Ensuring cleanup with
finally. - An alternative:
Future.catchError(). - Best practices for building resilient apps.
Proper error handling is key to creating stable and user-friendly mobile experiences!
เรียนรู้ Dart ด้วย AI tutor — ฟรี
เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป
- คอร์ส
- 22
- บทเรียน
- 88
คำถามที่พบบ่อย
บทเรียน “การจัดการข้อผิดพลาดแบบอะซิงโครนัส” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “การจัดการข้อผิดพลาดแบบอะซิงโครนัส” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Flutter Mobile Development ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Flutter Mobile Development มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “การจัดการข้อผิดพลาดแบบอะซิงโครนัส”
พัฒนากลยุทธ์การจัดการข้อผิดพลาดที่มีประสิทธิภาพสำหรับการดำเนินการแบบอะซิงโครนัส เพื่อให้แอปจัดการความล้มเหลวของเครือข่ายและข้อยกเว้นได้อย่างเหมาะสม คุณปฏิบัติ Flutter Mobile Development ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Flutter Mobile Development หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Flutter Mobile Development บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน
บทเรียน “การจัดการข้อผิดพลาดแบบอะซิงโครนัส” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Flutter Mobile Development นี้ได้ไหม
ได้ บทเรียน Flutter Mobile Development ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- Futures และ Async/Await
- คำขอ HTTP และ JSON
- การจัดการข้อผิดพลาดแบบอะซิงโครนัส
- สตรีมและข้อมูลแบบรีแอกทีฟ