Mobiludvikling med Flutter · Lektion

Fejlhåndtering i asynkron kode

Implementer robuste strategier til fejlhåndtering i asynkrone operationer, så Deres app håndterer netværksfejl og undtagelser på en elegant måde.

Lektion 3 af 411 trin

Fejlhåndtering i asynkron kode er en gratis Mobiludvikling med Flutter-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Mobiludvikling med Flutter, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Mobiludvikling med Flutter-kurset indeholder 4 lektioner i alt.

Håndtering af uforudsigelige asynkrone fejl

Asynkrone handlinger som at hente data fra internettet eller læse filer er i sagens natur uforudsigelige. De kan lykkes, mislykkes eller endda få timeout.

Robust fejlhåndtering er afgørende for at forhindre, at din app går ned, og for at give en god brugeroplevelse. Den gør det muligt at håndtere disse fejl på en hensigtsmæssig måde.

`try-catch` til asynkrone handlinger

Den velkendte try-catch-blok i Dart er dit primære værktøj til at håndtere undtagelser i asynkron kode. Når et await-udtryk kaster en fejl, kan den fanges af en omsluttende try-catch-blok.

try: Indeholder den kode, der kan kaste en undtagelse.
catch: Fanger og håndterer undtagelsen, hvis der opstår en.
on: (Valgfrit) Fanger bestemte typer undtagelser.

Fang en simuleret fejl

Lad os se try-catch i praksis. Dette eksempel simulerer en netværksfejl ved at kaste en Exception i en asynkron funktion. Bemærk, hvordan catch håndterer den.

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

Håndtér bestemte typer undtagelser

Nogle gange vil du håndtere forskellige typer fejl på forskellige måder. Nøgleordet on gør det muligt at fange bestemte typer undtagelser, så din fejlhåndtering bliver mere præcis.

Du kan for eksempel håndtere en SocketException (netværksproblem) anderledes end en generisk Exception.

Målrettet fejlhåndtering

Her definerer vi to typer fejl: en tilpasset NetworkException og en generisk Exception. on-sætningen gør det muligt at angive specifik håndtering for hver af dem.

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

Sørg for oprydning med `finally`

finally-blokken er en valgfri del af en try-catch-sætning. Koden i denne blok bliver altid udført, uanset om der blev kastet eller fanget en undtagelse.

Den er perfekt til oprydning, f.eks. til at lukke en filstrøm eller skjule en indlæsningsindikator, så ressourcerne håndteres korrekt.

Alternativ: `Future.catchError`

Selvom try-catch fungerer godt sammen med async/await, kan du også håndtere fejl direkte på et Future-objekt ved hjælp af dets .catchError()-metode. Det bruges ofte, når du kæder Futures sammen, eller når du ikke bruger await med det samme.

Metoden modtager en funktion, der bliver kaldt, hvis Future afsluttes med en fejl.

Håndtér fejl med `catchError`

Sådan kan .catchError() bruges. Bemærk, at fejlen håndteres som en del af Futures afslutningskæde uden at kræve en async-funktion eller await til selve fejlhåndteringen.

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

God praksis for fejlhåndtering

Effektiv fejlhåndtering gør din app robust og brugervenlig:

Log fejl: Brug et logningssystem til at registrere fejl med henblik på fejlfinding.
Giv feedback: Fortæl brugeren, hvad der gik galt (f.eks. "Netværket er utilgængeligt").
Gentagelsesmekanisme: Ved midlertidige netværksproblemer kan du overveje at tilbyde en mulighed for at prøve igen.
Undgå tomme catch-blokke: Håndtér altid fejl, eller kast dem igen; slug dem ikke bare.

Kontrol af asynkron fejlhåndtering

Se på følgende Dart-kodestykke. Hvilke udsagn om dets fejlhåndtering er sande?

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

Besvar den i den interaktive lektion

Opsummering: Få styr på asynkrone fejl

I denne lektion undersøgte vi, hvordan du håndterer fejl i asynkrone Dart- og Flutter-applikationer. Du lærte:

Hvor vigtig robust fejlhåndtering er.
At bruge try-catch sammen med async/await.
At fange bestemte undtagelser med on.
At sørge for oprydning med finally.
Et alternativ: Future.catchError().
Bedste praksis til at bygge modstandsdygtige apps.

Korrekt fejlhåndtering er afgørende for at skabe stabile og brugervenlige mobiloplevelser!

Gratis at komme i gang

Lær Dart med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 22
Lektioner: 88

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Fejlhåndtering i asynkron kode” gratis?

Ja — alle 3 lektioner i læringssporet Mobiludvikling med Flutter, inklusive “Fejlhåndtering i asynkron kode”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Mobiludvikling med Flutter-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Fejlhåndtering i asynkron kode”?

Implementer robuste strategier til fejlhåndtering i asynkrone operationer, så Deres app håndterer netværksfejl og undtagelser på en elegant måde. Du øver dig i Mobiludvikling med Flutter med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Mobiludvikling med Flutter?

Der kræves ingen tidligere erfaring. Mobiludvikling med Flutter på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Fejlhåndtering i asynkron kode”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Mobiludvikling med Flutter-lektion?

Ja. Alle Mobiludvikling med Flutter-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Mobiludvikling med Flutter